Add Delete API to Calling Server Client (#21130)

* Initial delete changes

* Record delete tests. Move common delete and download code to utils

* Lint fixes

* Removing debug statements

* Update file missed in merge conflict

* Fix urlparse import issue. PR feedback.

* Fix lint issues

Co-authored-by: Melissa Neubert <[email protected]>

Author: melneubert

sdk/communication/azure-communication-callingserver/azure/communication/callingserver/_callingserver_client.py

@@ -7,9 +7,15 @@
 from typing import TYPE_CHECKING, Any, List, Optional  # pylint: disable=unused-import
 from azure.core.tracing.decorator import distributed_trace
 from azure.core.pipeline.transport import HttpResponse
+from azure.core.exceptions import (
+    HttpResponseError,
+    map_error
+)
+
 from .utils._utils import CallingServerUtils
 from ._content_downloader import ContentDownloader
 from ._download import ContentStreamDownloader
+
 from ._communication_identifier_serializer import serialize_identifier
 from ._communication_call_locator_serializer import serialize_call_locator
 from ._generated._azure_communication_calling_server_service import \
@@ -52,7 +58,7 @@
     HoldMeetingAudioWithCallLocatorRequestConverter,
     ResumeMeetingAudioWithCallLocatorRequestConverter
     )
-from ._shared.utils import get_authentication_policy, parse_connection_str
+from ._shared.utils import get_authentication_policy, get_host_header_policy, parse_connection_str
 from ._version import SDK_MONIKER
 
 if TYPE_CHECKING:
@@ -101,6 +107,7 @@ def __init__(
         self._endpoint = endpoint
         self._callingserver_service_client = AzureCommunicationCallingServerService(
             self._endpoint,
+            headers_policy=get_host_header_policy(endpoint, credential),
             authentication_policy=get_authentication_policy(endpoint, credential),
             sdk_moniker=SDK_MONIKER,
             **kwargs)
@@ -731,3 +738,38 @@ def download(
             parallel_download_options=parallel_download_options,
             **kwargs
         )
+
+    @distributed_trace()
+    def delete_recording(
+        self,
+        content_delete_url, # type: str
+        **kwargs # type: Any
+
+    ): # type: (...) -> HttpResponse
+        # pylint: disable=protected-access
+        if not content_delete_url:
+            raise ValueError("content_delete_url can not be None")
+
+        url = content_delete_url
+        uri_to_sign_with = CallingServerUtils.get_url_to_sign_request_with(self._endpoint, url)
+
+        query_parameters = {} # type: Dict[str, Any]
+        # Construct headers
+        header_parameters = {}  # type: Dict[str, Any]
+        header_parameters['UriToSignWith'] = self._callingserver_service_client._serialize.header(
+            name="uri_to_sign_with",
+            data=uri_to_sign_with,
+            data_type='str')
+
+        error_map = CallingServerUtils.get_error_response_map(
+            kwargs.pop('error_map', {}))
+        client = self._callingserver_service_client._client
+        request = client.delete(url, query_parameters, header_parameters) #pylint: disable=specify-parameter-names-in-call
+        pipeline_response = client._pipeline.run(request, **kwargs)
+        response = pipeline_response.http_response
+        if response.status_code not in [200]:
+            map_error(status_code=response.status_code,
+                        response=response, error_map=error_map)
+            raise HttpResponseError(response=response)
+
+        return response

sdk/communication/azure-communication-callingserver/azure/communication/callingserver/_content_downloader.py

@@ -12,27 +12,21 @@
 
 from typing import IO, TYPE_CHECKING
 
-try:
-    from urllib.parse import urlparse
-except ImportError:
-    from urlparse import urlparse # type: ignore
-
 from msrest import Deserializer, Serializer
 from azure.core import PipelineClient
 from azure.core.exceptions import (
-    ClientAuthenticationError,
     HttpResponseError,
-    ResourceExistsError,
-    ResourceNotFoundError,
     map_error
 )
 from azure.core.pipeline import PipelineResponse
 from azure.core.pipeline.transport import HttpRequest, HttpResponse
 from ._generated import models as _models
 from ._generated._configuration import AzureCommunicationCallingServerServiceConfiguration
+from .utils._utils import CallingServerUtils
+
 
 if TYPE_CHECKING:
-    # pylint: disable=unused-import,ungrouped-imports
+    # pylint: disable=unused-import,ungrouped-imports,unsubscriptable-object
     from typing import Any, Callable, Dict, Optional, TypeVar
 
     T = TypeVar('T')
@@ -49,8 +43,6 @@ class ContentDownloader(object):
     :type models: ~azure.communication.callingserver.models
     :param client: Client for service requests.
     :param config: Configuration of service client.
-    :param serializer: An object model serializer.
-    :param deserializer: An object model deserializer.
     """
 
     models = _models
@@ -85,28 +77,10 @@ def download(
         """
 
         cls = kwargs.pop('cls', None)  # type: ClsType[IO]
-        error_map = {
-            409: ResourceExistsError,
-            400: lambda response: HttpResponseError(response=response,
-                                                    model=self._deserialize(_models.CommunicationErrorResponse,
-                                                                            response)),
-            401: lambda response: ClientAuthenticationError(response=response,
-                                                            model=self._deserialize(_models.CommunicationErrorResponse,
-                                                                                    response)),
-            403: lambda response: HttpResponseError(response=response,
-                                                    model=self._deserialize(_models.CommunicationErrorResponse,
-                                                                            response)),
-            404: lambda response: ResourceNotFoundError(response=response,
-                                                        model=self._deserialize(_models.CommunicationErrorResponse,
-                                                                                response)),
-            500: lambda response: HttpResponseError(response=response,
-                                                    model=self._deserialize(_models.CommunicationErrorResponse,
-                                                                            response)),
-        }
-        error_map.update(kwargs.pop('error_map', {}))
+        error_map = CallingServerUtils.get_error_response_map(kwargs.pop('error_map', {}))
 
         url = content_url
-        uri_to_sign_with = self.get_url_to_sign_request_with(url)
+        uri_to_sign_with = CallingServerUtils.get_url_to_sign_request_with(self._config.endpoint, url)
 
         # Construct parameters
         query_parameters = {}  # type: Dict[str, Any]
@@ -128,10 +102,3 @@ def download(
             return cls(pipeline_response, deserialized, {})
 
         return deserialized
-
-
-    def get_url_to_sign_request_with(self,
-        content_url # type: str
-    ): # type: (...) -> str
-        path = urlparse(content_url).path
-        return self._config.endpoint + path

sdk/communication/azure-communication-callingserver/azure/communication/callingserver/_shared/utils.py

@@ -14,6 +14,7 @@
 import calendar
 from msrest.serialization import TZ_UTC
 from azure.core.credentials import AccessToken
+from azure.core.pipeline.policies import HeadersPolicy
 
 
 def _convert_datetime_to_utc_int(expires_on):
@@ -119,3 +120,35 @@ def get_authentication_policy(
 
     raise TypeError("Unsupported credential: {}. Use an access token string to use HMACCredentialsPolicy"
                     "or a token credential from azure.identity".format(type(credential)))
+
+def get_host_header_policy(
+        host, # type: str
+        credential, # type: TokenCredential or str
+):
+    # type: (...) -> HeadersPolicy or None
+    """Returns the correct header policy based
+    on which credential is being passed.
+    :param host: The resource host name.
+    :param credential: The credential we use to authenticate to the service
+    :type credential: TokenCredential or str
+    :rtype: ~azure.core.pipeline.policies.HeadersPolicy
+    ~None
+    """
+
+    if host.startswith("https://"):
+        host = host.replace("https://", "")
+
+    if host.startswith("http://"):
+        host = host.replace("http://", "")
+
+    header_policy = HeadersPolicy({
+        'x-ms-host': host
+    })
+
+    if hasattr(credential, "get_token"):
+        return header_policy
+    if isinstance(credential, str):
+        return None
+
+    raise TypeError("Unsupported credential: {}. Use an access token string to use HMACCredentialsPolicy"
+                "or a token credential from azure.identity".format(type(credential)))

sdk/communication/azure-communication-callingserver/azure/communication/callingserver/aio/_callingserver_client_async.py

@@ -12,6 +12,10 @@
 
 from azure.core.tracing.decorator_async import distributed_trace_async
 from azure.core.pipeline.transport import HttpResponse
+from azure.core.exceptions import (
+    HttpResponseError,
+    map_error
+)
 
 from ..utils._utils import CallingServerUtils
 from .._communication_identifier_serializer import serialize_identifier
@@ -58,7 +62,7 @@
     HoldMeetingAudioWithCallLocatorRequestConverter,
     ResumeMeetingAudioWithCallLocatorRequestConverter
     )
-from .._shared.utils import get_authentication_policy, parse_connection_str
+from .._shared.utils import get_authentication_policy, get_host_header_policy, parse_connection_str
 from .._version import SDK_MONIKER
 
 if TYPE_CHECKING:
@@ -100,6 +104,7 @@ def __init__(
         self._endpoint = endpoint
         self._callingserver_service_client = AzureCommunicationCallingServerService(
             self._endpoint,
+            headers_policy=get_host_header_policy(endpoint, credential),
             authentication_policy=get_authentication_policy(endpoint, credential, decode_url=True, is_async=True),
             sdk_moniker=SDK_MONIKER,
             **kwargs
@@ -728,6 +733,41 @@ async def download(
         await stream_downloader._setup()
         return stream_downloader
 
+    @distributed_trace_async()
+    async def delete_recording(
+        self,
+        content_delete_url: str,
+        **kwargs: Any
+
+    ): # type: (...) -> HttpResponse
+        # pylint: disable=protected-access
+        if not content_delete_url:
+            raise ValueError("content_delete_url can not be None")
+
+        uri_to_sign_with = CallingServerUtils.get_url_to_sign_request_with(self._endpoint, content_delete_url)
+
+        query_parameters = {} # type: Dict[str, Any]
+        # Construct headers
+        header_parameters = {}  # type: Dict[str, Any]
+        header_parameters['UriToSignWith'] = self._callingserver_service_client._serialize.header(
+            name="uri_to_sign_with",
+            data=uri_to_sign_with,
+            data_type='str')
+
+        error_map = CallingServerUtils.get_error_response_map(
+            kwargs.pop('error_map', {}))
+
+        client = self._callingserver_service_client._client
+        request = client.delete(content_delete_url, query_parameters, header_parameters) #pylint: disable=specify-parameter-names-in-call
+        pipeline_response = await client._pipeline.run(request, stream=False, **kwargs)
+        response = pipeline_response.http_response
+        if response.status_code not in [200]:
+            map_error(status_code=response.status_code,
+                        response=response, error_map=error_map)
+            raise HttpResponseError(response=response)
+
+        return response
+
     async def close(self) -> None:
         """Close the :class:
         `~azure.communication.callingserver.aio.CallingServerClient` session.

sdk/communication/azure-communication-callingserver/azure/communication/callingserver/aio/_content_downloader_async.py

@@ -11,15 +11,13 @@
 from typing import Any, IO, Optional, TYPE_CHECKING
 from urllib.parse import urlparse
 
+from azure.core.exceptions import HttpResponseError, map_error
 from azure.core.pipeline import PipelineResponse
 from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest
-from azure.core.exceptions import (ClientAuthenticationError, HttpResponseError,
-    ResourceExistsError, ResourceNotFoundError, map_error)
-
-from .._generated import models as _models
+from ..utils._utils import CallingServerUtils
 
 if TYPE_CHECKING:
-    # pylint: disable=unused-import,ungrouped-imports
+    # pylint: disable=unused-import,ungrouped-imports,unsubscriptable-object
     from typing import Callable, Dict, Generic, TypeVar
 
     T = TypeVar('T')
@@ -50,25 +48,9 @@ async def download(
         :raises: ~azure.core.exceptions.HttpResponseError
         """
         cls = kwargs.pop('cls', None)  # type: ClsType[IO]
-        error_map = {
-            409: ResourceExistsError,
-            400: lambda response: HttpResponseError(response=response,
-                                                    model=self._deserialize(_models.CommunicationErrorResponse,
-                                                                            response)),
-            401: lambda response: ClientAuthenticationError(response=response,
-                                                            model=self._deserialize(_models.CommunicationErrorResponse,
-                                                                                    response)),
-            403: lambda response: HttpResponseError(response=response,
-                                                    model=self._deserialize(_models.CommunicationErrorResponse,
-                                                                            response)),
-            404: lambda response: ResourceNotFoundError(response=response,
-                                                        model=self._deserialize(_models.CommunicationErrorResponse,
-                                                                                response)),
-            500: lambda response: HttpResponseError(response=response,
-                                                    model=self._deserialize(_models.CommunicationErrorResponse,
-                                                                            response)),
-        }
-        error_map.update(kwargs.pop('error_map', {}))
+        error_map = CallingServerUtils.get_error_response_map(
+            kwargs.pop('error_map', {}))
+
 
         # Construct URL
         uri_to_sign_with = self._get_url_to_sign_request_with(content_url)

sdk/communication/azure-communication-callingserver/azure/communication/callingserver/utils/_utils.py

@@ -4,8 +4,19 @@
 # license information.
 # --------------------------------------------------------------------------
 
+try:
+    from urllib.parse import urlparse
+except ImportError:
+    from urlparse import urlparse # type: ignore
 import validators
 
+from azure.core.exceptions import (
+    ClientAuthenticationError,
+    HttpResponseError,
+    ResourceExistsError,
+    ResourceNotFoundError,
+)
+
 class CallingServerUtils(object):
 
     @staticmethod
@@ -46,3 +57,26 @@ def validate_and_format_range_headers(start_range, end_range):
             range_header = "bytes={0}-".format(start_range)
 
         return range_header
+
+    @staticmethod
+    def get_url_to_sign_request_with(
+        resource_endpoint, # type: str
+        content_url # type: str
+    ): # type: (...) -> str
+        path = urlparse(content_url).path
+        return resource_endpoint + path
+
+    @staticmethod
+    def get_error_response_map(
+        additional_errors
+    ):
+        error_map = {
+            400: HttpResponseError,
+            401: ClientAuthenticationError,
+            403: HttpResponseError,
+            404: ResourceNotFoundError,
+            409: ResourceExistsError,
+            500: HttpResponseError
+        }
+        error_map.update(additional_errors)
+        return error_map