def post(self,
url: str,
loop: "asyncio.AbstractEventLoop",
data: "Any" = None,
headers: "Optional[Dict[str, str]]" = None,
params: "Optional[Dict[str, str]]" = None,
timeout: "Optional[float]" = None,
verify: "Optional[bool]" = None,
**kwargs: "Any") -> MsalTransportResponse:
request = HttpRequest("POST", url, headers=headers)
if params:
request.format_parameters(params)
if data:
request.headers[
"Content-Type"] = "application/x-www-form-urlencoded"
request.set_formdata_body(data)
future = asyncio.run_coroutine_threadsafe( # type: ignore
self._pipeline.run(request,
connection_timeout=timeout,
connection_verify=verify,
**kwargs), loop)
response = future.result(timeout=timeout)
return MsalTransportResponse(response)
def test_request_url_with_params(self):
request = HttpRequest("GET", "/")
request.url = "a/b/c?t=y"
request.format_parameters({"g": "h"})
self.assertIn(request.url, ["a/b/c?g=h&t=y", "a/b/c?t=y&g=h"])
def test_request_url_with_params():
request = HttpRequest("GET", "/")
request.url = "a/b/c?t=y"
request.format_parameters({"g": "h"})
assert request.url in ["a/b/c?g=h&t=y", "a/b/c?t=y&g=h"]
def get_key(self, name, version="", **kwargs):
# type: (str, str, Any) -> Key
"""Gets the public part of a stored key.
The get key operation is applicable to all key types. If the requested
key is symmetric, then no key material is released in the response.
This operation requires the keys/get permission.
:param name: The name of the key to get.
:type name: str
:param version: Adding the version parameter retrieves a specific
version of the key.
:type version: str
:return: Key
:rtype: ~azure.keyvault.keys.Key
"""
url = "/".join([self.vault_url, "keys", name, version])
request = HttpRequest("GET", url)
request.format_parameters({"api-version": self.API_VERSION})
response = self._pipeline.run(request, **kwargs).http_response
if response.status_code != 200:
raise HttpResponseError("Request failed with code {}: '{}'".format(response.status_code, response.text()))
key = self._deserialize("Key", response)
return key
def test_request_url_with_params_as_list(self):
request = HttpRequest("GET", "/")
request.url = "a/b/c?t=y"
request.format_parameters({"g": ["h", "i"]})
self.assertIn(request.url, ["a/b/c?g=h&g=i&t=y", "a/b/c?t=y&g=h&g=i"])
def get(self, url, params=None, headers=None, **kwargs): # pylint:disable=unused-argument
# type: (str, Optional[Dict[str, str]], Optional[Dict[str, str]], **Any) -> MsalResponse
request = HttpRequest("GET", url, headers=headers)
if params:
request.format_parameters(params)
response = self._pipeline.run(request)
return MsalResponse(response)
def get_request(scope, identity_config):
request = HttpRequest("GET", IMDS_URL)
request.format_parameters(
dict({
"api-version": "2018-02-01",
"resource": scope
}, **identity_config))
return request
def get(self, url, headers=None, params=None, timeout=None, verify=None, **kwargs):
# type: (str, Optional[Mapping[str, str]], Optional[Dict[str, str]], float, bool, Any) -> MsalTransportResponse
request = HttpRequest("GET", url, headers=headers)
if params:
request.format_parameters(params)
response = self._pipeline.run(
request, stream=False, connection_timeout=timeout, connection_verify=verify, **kwargs
)
return MsalTransportResponse(response)
def _get_request(url, scope, identity_config):
# type: (str, str, dict) -> HttpRequest
request = HttpRequest("GET", url)
request.format_parameters(
dict({
"api-version": "2017-09-01",
"resource": scope
}, **identity_config))
return request
def get_request(scope, identity_config):
request = HttpRequest(
"GET",
os.environ.get(EnvironmentVariables.AZURE_POD_IDENTITY_TOKEN_URL,
IMDS_URL))
request.format_parameters(
dict({
"api-version": "2018-02-01",
"resource": scope
}, **identity_config))
return request
async def set_standard_blob_tier_blobs(
self, standard_blob_tier: Union[str, 'StandardBlobTier'],
*blobs: Union[str, BlobProperties],
**kwargs) -> AsyncIterator[AsyncHttpResponse]:
"""This operation sets the tier on block blobs.
A block blob's tier determines Hot/Cool/Archive storage type.
This operation does not update the blob's ETag.
:param standard_blob_tier:
Indicates the tier to be set on the blob. Options include 'Hot', 'Cool',
'Archive'. The hot tier is optimized for storing data that is accessed
frequently. The cool storage tier is optimized for storing data that
is infrequently accessed and stored for at least a month. The archive
tier is optimized for storing data that is rarely accessed and stored
for at least six months with flexible latency requirements.
:type standard_blob_tier: str or ~azure.storage.blob.StandardBlobTier
:param blobs: The blobs with which to interact.
:type blobs: str
:keyword int timeout:
The timeout parameter is expressed in seconds.
:keyword lease:
Required if the blob has an active lease. Value can be a BlobLeaseClient object
or the lease ID as a string.
:paramtype lease: ~azure.storage.blob.aio.BlobLeaseClient or str
:keyword bool raise_on_any_failure:
This is a boolean param which defaults to True. When this is set, an exception
is raised even if there is a single operation failure. For optimal performance,
this should be set to False.
:return: An async iterator of responses, one for each blob in order
:rtype: asynciterator[~azure.core.pipeline.transport.AsyncHttpResponse]
"""
access_conditions = get_access_conditions(kwargs.pop('lease', None))
if standard_blob_tier is None:
raise ValueError("A StandardBlobTier must be specified")
query_parameters, header_parameters = self._generate_set_tier_options(
tier=standard_blob_tier,
lease_access_conditions=access_conditions,
**kwargs)
# To pass kwargs to "_batch_send", we need to remove anything that was
# in the Autorest signature for Autorest, otherwise transport will be upset
for possible_param in ['timeout', 'lease']:
kwargs.pop(possible_param, None)
reqs = []
for blob in blobs:
req = HttpRequest("PUT",
"/{}/{}".format(self.container_name, blob),
headers=header_parameters)
req.format_parameters(query_parameters)
reqs.append(req)
return await self._batch_send(*reqs, **kwargs)
def get_request(scope, identity_config):
url = (
os.environ.get(EnvironmentVariables.AZURE_POD_IDENTITY_AUTHORITY_HOST,
IMDS_AUTHORITY).strip("/") + IMDS_TOKEN_PATH)
request = HttpRequest("GET", url)
request.format_parameters(
dict({
"api-version": "2018-02-01",
"resource": scope
}, **identity_config))
return request
def _get_request(url, scope, identity_config):
# type: (str, str, dict) -> HttpRequest
if identity_config:
raise ClientAuthenticationError(
message="User assigned managed identities are not supported by Azure Arc. To authenticate with the system "
"assigned identity omit the client id when constructing the credential, and if authenticating with "
"DefaultAzureCredential ensure the AZURE_CLIENT_ID environment variable is not set."
)
request = HttpRequest("GET", url)
request.format_parameters(dict({"api-version": "2019-11-01", "resource": scope}, **identity_config))
return request
def purge_deleted_key(self, name, **kwargs):
# type: (str, Any) -> None
url = "/".join([self.vault_url, "deletedkeys", name])
request = HttpRequest("DELETE", url)
request.format_parameters({"api-version": self.API_VERSION})
response = self._pipeline.run(request, **kwargs).http_response
if response.status_code != 204:
raise HttpResponseError("Request failed with code {}: '{}'".format(response.status_code, response.text()))
return
def get_deleted_key(self, name, **kwargs):
# type: (str, Any) -> DeletedKey
url = "/".join([self.vault_url, "deletedkeys", name])
request = HttpRequest("GET", url)
request.format_parameters({"api-version": self.API_VERSION})
response = self._pipeline.run(request, **kwargs).http_response
if response.status_code != 200:
raise HttpResponseError("Request failed with code {}: '{}'".format(response.status_code, response.text()))
deleted_key = self._deserialize("DeletedKey", response)
return deleted_key
async def set_premium_page_blob_tier_blobs(
self, premium_page_blob_tier: Union[str, 'PremiumPageBlobTier'],
*blobs: Union[str, BlobProperties],
**kwargs) -> AsyncIterator[AsyncHttpResponse]:
"""Sets the page blob tiers on the blobs. This API is only supported for page blobs on premium accounts.
:param premium_page_blob_tier:
A page blob tier value to set the blob to. The tier correlates to the size of the
blob and number of allowed IOPS. This is only applicable to page blobs on
premium storage accounts.
:type premium_page_blob_tier: ~azure.storage.blob.PremiumPageBlobTier
:param blobs: The blobs with which to interact.
:type blobs: str or ~azure.storage.blob.BlobProperties
:keyword int timeout:
The timeout parameter is expressed in seconds. This method may make
multiple calls to the Azure service and the timeout will apply to
each call individually.
:keyword lease:
Required if the blob has an active lease. Value can be a BlobLeaseClient object
or the lease ID as a string.
:paramtype lease: ~azure.storage.blob.aio.BlobLeaseClient or str
:keyword bool raise_on_any_failure:
This is a boolean param which defaults to True. When this is set, an exception
is raised even if there is a single operation failure. For optimal performance,
this should be set to False.
:return: An async iterator of responses, one for each blob in order
:rtype: asynciterator[~azure.core.pipeline.transport.AsyncHttpResponse]
"""
access_conditions = get_access_conditions(kwargs.pop('lease', None))
if premium_page_blob_tier is None:
raise ValueError("A PremiumPageBlobTier must be specified")
query_parameters, header_parameters = self._generate_set_tier_options(
tier=premium_page_blob_tier,
lease_access_conditions=access_conditions,
**kwargs)
# To pass kwargs to "_batch_send", we need to remove anything that was
# in the Autorest signature for Autorest, otherwise transport will be upset
for possible_param in ['timeout', 'lease']:
kwargs.pop(possible_param, None)
reqs = []
for blob in blobs:
req = HttpRequest("PUT",
"/{}/{}".format(self.container_name, blob),
headers=header_parameters)
req.format_parameters(query_parameters)
reqs.append(req)
return await self._batch_send(*reqs, **kwargs)
def _prepare_request(
self,
method="POST", # type: Optional[str]
headers=None, # type: Optional[Mapping[str, str]]
form_data=None, # type: Optional[Mapping[str, str]]
params=None, # type: Optional[Dict[str, str]]
):
# type: (...) -> HttpRequest
request = HttpRequest(method, self._auth_url, headers=headers)
if form_data:
request.headers["Content-Type"] = "application/x-www-form-urlencoded"
request.set_formdata_body(form_data)
if params:
request.format_parameters(params)
return request
def update_key(self, name, version, key_ops=None, attributes=None, tags=None, **kwargs):
# type: (str, str, Optional[List[str]], Mapping[str, str], Mapping[str, str], Any) -> Key
url = "/".join([self.vault_url, "keys", name, version])
headers = {"Content-Type": "application/json; charset=utf-8", "x-ms-client-request-id": str(uuid.uuid1())}
update_params = KeyUpdateParameters(key_ops=key_ops, key_attributes=attributes, tags=tags)
body = self._serialize.body(update_params, "KeyUpdateParameters")
request = HttpRequest("PATCH", url, headers=headers)
request.set_json_body(body)
request.format_parameters({"api-version": self.API_VERSION})
response = self._pipeline.run(request, **kwargs).http_response
if response.status_code != 200:
raise HttpResponseError("Request failed with code {}: '{}'".format(response.status_code, response.text()))
key = self._deserialize("Key", response)
return key
def post(self, url, params=None, data=None, headers=None, **kwargs): # pylint:disable=unused-argument
# type: (str, Optional[Dict[str, str]], RequestData, Optional[Dict[str, str]], **Any) -> MsalResponse
request = HttpRequest("POST", url, headers=headers)
if params:
request.format_parameters(params)
if data:
if isinstance(data, dict):
request.headers["Content-Type"] = "application/x-www-form-urlencoded"
request.set_formdata_body(data)
elif isinstance(data, six.text_type):
body_bytes = six.ensure_binary(data)
request.set_bytes_body(body_bytes)
else:
raise ValueError('expected "data" to be text or a dict')
response = self._pipeline.run(request, stream=False, retry_on_methods=_POST)
self._store_auth_error(response)
return MsalResponse(response)
def post(
self,
url, # type: str
data=None, # type: Optional[Mapping[str, str]]
headers=None, # type: Optional[Mapping[str, str]]
params=None, # type: Optional[Dict[str, str]]
timeout=None, # type: float
verify=None, # type: bool
**kwargs # type: Any
):
# type: (...) -> MsalTransportResponse
request = HttpRequest("POST", url, headers=headers)
if params:
request.format_parameters(params)
if data:
request.headers["Content-Type"] = "application/x-www-form-urlencoded"
request.set_formdata_body(data)
response = self._pipeline.run(
request, stream=False, connection_timeout=timeout, connection_verify=verify, **kwargs
)
return MsalTransportResponse(response)
def _internal_paging(self, url, max_page_size, next_link=None, raw=False, **kwargs):
# type: (str, int, Optional[str], Optional[bool], Any) -> HttpResponse
if next_link:
url = next_link
query_parameters = {}
else:
query_parameters = {"api-version": self.API_VERSION}
if max_page_size is not None:
query_parameters["maxresults"] = str(max_page_size)
headers = {"x-ms-client-request-id": str(uuid.uuid1())}
request = HttpRequest("GET", url, headers)
request.format_parameters(query_parameters)
response = self._pipeline.run(request, **kwargs).http_response
if response.status_code != 200:
raise HttpResponseError("Request failed with code {}: '{}'".format(response.status_code, response.text()))
return response
def get(self,
url: str,
loop: "asyncio.AbstractEventLoop",
headers: "Optional[Dict[str, str]]" = None,
params: "Optional[Dict[str, str]]" = None,
timeout: "Optional[float]" = None,
verify: "Optional[bool]" = None,
**kwargs: "Any") -> MsalTransportResponse:
request = HttpRequest("GET", url, headers=headers)
if params:
request.format_parameters(params)
future = asyncio.run_coroutine_threadsafe( # type: ignore
self._pipeline.run(request,
connection_timeout=timeout,
connection_verify=verify,
**kwargs), loop)
response = future.result(timeout=timeout)
return MsalTransportResponse(response)
def _build_request(endpoint, content_type, events):
serialize = Serializer()
header_parameters = {} # type: Dict[str, Any]
header_parameters['Content-Type'] = serialize.header(
"content_type", content_type, 'str')
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = serialize.query("api_version",
"2018-01-01", 'str')
body = serialize.body(events, '[object]')
if body is None:
data = None
else:
data = json.dumps(body)
header_parameters['Content-Length'] = str(len(data))
request = HttpRequest(method="POST",
url=endpoint,
headers=header_parameters,
data=data)
request.format_parameters(query_parameters)
return request
def test_request_url_with_params_with_none(self):
request = HttpRequest("GET", "/")
request.url = "a/b/c?t=y"
with pytest.raises(ValueError):
request.format_parameters({"g": None})
def test_request_url_with_params_with_none_in_list():
request = HttpRequest("GET", "/")
request.url = "a/b/c?t=y"
with pytest.raises(ValueError):
request.format_parameters({"g": ["h",None]})
async def delete_blobs( # pylint: disable=arguments-differ
self,
*blobs: Union[str, BlobProperties],
delete_snapshots: Optional[str] = None,
lease: Optional[Union[str, BlobLeaseClient]] = None,
**kwargs) -> AsyncIterator[AsyncHttpResponse]:
"""Marks the specified blobs or snapshots for deletion.
The blobs are later deleted during garbage collection.
Note that in order to delete blobs, you must delete all of their
snapshots. You can delete both at the same time with the delete_blobs operation.
If a delete retention policy is enabled for the service, then this operation soft deletes the blobs or snapshots
and retains the blobs or snapshots for specified number of days.
After specified number of days, blobs' data is removed from the service during garbage collection.
Soft deleted blobs or snapshots are accessible through :func:`list_blobs()` specifying `include=["deleted"]`
Soft-deleted blobs or snapshots can be restored using :func:`~BlobClient.undelete()`
:param blobs: The blob names with which to interact.
:type blobs: str
:param str delete_snapshots:
Required if a blob has associated snapshots. Values include:
- "only": Deletes only the blobs snapshots.
- "include": Deletes the blob along with all snapshots.
:param lease:
Required if a blob has an active lease. Value can be a BlobLeaseClient object
or the lease ID as a string.
:type lease: ~azure.storage.blob.aio.BlobLeaseClient or str
:keyword ~datetime.datetime if_modified_since:
A DateTime value. Azure expects the date value passed in to be UTC.
If timezone is included, any non-UTC datetimes will be converted to UTC.
If a date is passed in without timezone info, it is assumed to be UTC.
Specify this header to perform the operation only
if the resource has been modified since the specified time.
:keyword ~datetime.datetime if_unmodified_since:
A DateTime value. Azure expects the date value passed in to be UTC.
If timezone is included, any non-UTC datetimes will be converted to UTC.
If a date is passed in without timezone info, it is assumed to be UTC.
Specify this header to perform the operation only if
the resource has not been modified since the specified date/time.
:keyword bool raise_on_any_failure:
This is a boolean param which defaults to True. When this is set, an exception
is raised even if there is a single operation failure. For optimal performance,
this should be set to False
:keyword str etag:
An ETag value, or the wildcard character (*). Used to check if the resource has changed,
and act according to the condition specified by the `match_condition` parameter.
:keyword ~azure.core.MatchConditions match_condition:
The match condition to use upon the etag.
:keyword int timeout:
The timeout parameter is expressed in seconds.
:return: An async iterator of responses, one for each blob in order
:rtype: asynciterator[~azure.core.pipeline.transport.AsyncHttpResponse]
"""
raise_on_any_failure = kwargs.pop('raise_on_any_failure', True)
timeout = kwargs.pop('timeout', None)
options = BlobClient._generic_delete_blob_options( # pylint: disable=protected-access
delete_snapshots=delete_snapshots,
lease=lease,
timeout=timeout,
**kwargs)
options.update({'raise_on_any_failure': raise_on_any_failure})
query_parameters, header_parameters = self._generate_delete_blobs_options(
**options)
# To pass kwargs to "_batch_send", we need to remove anything that was
# in the Autorest signature for Autorest, otherwise transport will be upset
for possible_param in [
'timeout', 'delete_snapshots', 'lease_access_conditions',
'modified_access_conditions'
]:
options.pop(possible_param, None)
reqs = []
for blob in blobs:
req = HttpRequest("DELETE",
"/{}/{}".format(self.container_name, blob),
headers=header_parameters)
req.format_parameters(query_parameters)
reqs.append(req)
return await self._batch_send(*reqs, **options)
