cloudbridge 4.4.2__tar.gz → 4.5.0__tar.gz

{cloudbridge-4.4.2 → cloudbridge-4.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudbridge
-Version: 4.4.2
+Version: 4.5.0
 Summary: A simple layer of abstraction over multiple cloud providers.
 Author-email: Galaxy and GVL Projects <help@genome.edu.au>
 License-Expression: MIT

{cloudbridge-4.4.2 → cloudbridge-4.5.0}/cloudbridge/__init__.py

@@ -3,7 +3,7 @@ import logging
 from typing import Any
 
 # Current version of the library
-__version__ = '4.4.2'
+__version__ = '4.5.0'
 
 
 def get_version() -> str:

{cloudbridge-4.4.2 → cloudbridge-4.5.0}/cloudbridge/base/resources.py

@@ -52,6 +52,7 @@ from cloudbridge.interfaces.resources import NetworkState
 from cloudbridge.interfaces.resources import ObjectLifeCycleMixin
 from cloudbridge.interfaces.resources import PageableObjectMixin
 from cloudbridge.interfaces.resources import PlacementZone
+from cloudbridge.interfaces.resources import PresignedRequest
 from cloudbridge.interfaces.resources import Region
 from cloudbridge.interfaces.resources import ResultList
 from cloudbridge.interfaces.resources import Router
@@ -734,16 +735,54 @@ class BaseRegion(BaseCloudResource, Region):
         return next(iter(self.zones))
 
 
+class BasePresignedRequest(PresignedRequest):
+    """
+    A presigned request, as concrete providers return it from
+    ``generate_upload_url`` and ``generate_part_url``.
+    """
+
+    def __init__(self, method: str, url: str,
+                 headers: dict[str, str] | None = None,
+                 enforces_size: bool = False) -> None:
+        self._method = method
+        self._url = url
+        self._headers = dict(headers or {})
+        self._enforces_size = enforces_size
+
+    @property
+    def method(self) -> str:
+        return self._method
+
+    @property
+    def url(self) -> str:
+        return self._url
+
+    @property
+    def headers(self) -> dict[str, str]:
+        return self._headers
+
+    @property
+    def enforces_size(self) -> bool:
+        return self._enforces_size
+
+    def __repr__(self) -> str:
+        # The query string carries the signature.
+        return "<CB-{0}: {1} {2}>".format(
+            self.__class__.__name__, self._method, self._url.split('?', 1)[0])
+
+
 class BaseUploadPart(UploadPart):
     """
     A simple, serializable handle for a single uploaded part. Concrete
-    providers return these from ``upload_part`` and consume them in
-    ``complete_multipart_upload``.
+    providers return these from ``upload_part``, ``reported_part`` and
+    ``list_parts``, and consume them in ``complete_multipart_upload``.
     """
 
-    def __init__(self, part_number: int, etag: object) -> None:
+    def __init__(self, part_number: int, etag: object,
+                 size: int | None = None) -> None:
         self._part_number = part_number
         self._etag = etag
+        self._size = size
 
     @property
     def part_number(self) -> int:
@@ -753,6 +792,10 @@ class BaseUploadPart(UploadPart):
     def etag(self) -> object:
         return self._etag
 
+    @property
+    def size(self) -> int | None:
+        return self._size
+
     def __repr__(self) -> str:
         return "<CB-{0}: {1} ({2})>".format(
             self.__class__.__name__, self._part_number, self._etag)
@@ -797,6 +840,19 @@ class BaseMultipartUpload(BaseCloudResource, MultipartUpload):
         return self._bucket_objects.upload_part(
             self._bucket, self, part_number, data)
 
+    def generate_part_url(self, part_number: int, expires_in: int,
+                          size: int | None = None) -> PresignedRequest:
+        return self._bucket_objects.generate_part_url(
+            self._bucket, self, part_number, expires_in, size)
+
+    def reported_part(self, part_number: int,
+                      etag: str | None) -> UploadPart:
+        return self._bucket_objects.reported_part(
+            self._bucket, self, part_number, etag)
+
+    def list_parts(self) -> list[UploadPart]:
+        return self._bucket_objects.list_parts(self._bucket, self)
+
     def complete(self, parts: list[UploadPart]) -> BucketObject:
         # pylint:disable=protected-access
         return self._bucket_objects.complete_multipart_upload(

{cloudbridge-4.4.2 → cloudbridge-4.5.0}/cloudbridge/base/subservices.py

@@ -12,7 +12,9 @@ from cloudbridge.interfaces.resources import DnsZone
 from cloudbridge.interfaces.resources import FloatingIP
 from cloudbridge.interfaces.resources import Gateway
 from cloudbridge.interfaces.resources import InternetGateway
+from cloudbridge.interfaces.resources import MultipartUpload
 from cloudbridge.interfaces.resources import Network
+from cloudbridge.interfaces.resources import PresignedRequest
 from cloudbridge.interfaces.resources import ResultList
 from cloudbridge.interfaces.resources import Subnet
 from cloudbridge.interfaces.resources import TrafficDirection
@@ -26,6 +28,7 @@ from cloudbridge.interfaces.subservices import GatewaySubService
 from cloudbridge.interfaces.subservices import SubnetSubService
 from cloudbridge.interfaces.subservices import VMFirewallRuleSubService
 
+from .resources import BaseMultipartUpload
 from .resources import BasePageableObjectMixin
 
 if TYPE_CHECKING:
@@ -66,6 +69,19 @@ class BaseBucketObjectSubService(BasePageableObjectMixin[BucketObject],
     def create(self, name: str) -> BucketObject:
         return self._bucket_objects.create(self.bucket, name)
 
+    def generate_upload_url(self, name: str, expires_in: int,
+                            size: int | None = None) -> PresignedRequest:
+        return self._bucket_objects.generate_upload_url(
+            self.bucket, name, expires_in, size)
+
+    def create_multipart_upload(self, name: str) -> MultipartUpload:
+        return self._bucket_objects.create_multipart_upload(self.bucket, name)
+
+    def get_multipart_upload(self, name: str,
+                             upload_id: str) -> MultipartUpload:
+        return BaseMultipartUpload(self._provider, self.bucket, name,
+                                   upload_id)
+
 
 class BaseGatewaySubService(GatewaySubService,
                             BasePageableObjectMixin[InternetGateway]):

{cloudbridge-4.4.2 → cloudbridge-4.5.0}/cloudbridge/interfaces/exceptions.py

@@ -102,3 +102,12 @@ class InvalidParamException(InvalidNameException):
 
     def __init__(self, msg: str) -> None:
         super(InvalidParamException, self).__init__(msg)
+
+
+class InvalidPartException(CloudBridgeBaseException):
+    """
+    Thrown when completing a multipart upload with parts the store does not
+    hold as reported: a part that was never uploaded, or one replaced after its
+    uploader received its ETag.
+    """
+    pass

{cloudbridge-4.4.2 → cloudbridge-4.5.0}/cloudbridge/interfaces/resources.py

@@ -2202,14 +2202,70 @@ class TransferConfig(object):
                     self.threshold, self.part_size, self.max_concurrency))
 
 
+class PresignedRequest(object):
+    """
+    A request to the object store that anyone holding it can send, without
+    credentials, until it expires.
+
+    Returned by :meth:`.BucketObjectSubService.generate_upload_url` and
+    :meth:`.MultipartUpload.generate_part_url`. Send the payload as the body of
+    a ``method`` request to ``url``, with ``headers``.
+    """
+    __metaclass__ = ABCMeta
+
+    @abstractproperty
+    def method(self) -> str:
+        """
+        The HTTP method of the request.
+
+        :rtype: ``str``
+        :return: The method, such as ``PUT``.
+        """
+        pass
+
+    @abstractproperty
+    def url(self) -> str:
+        """
+        The URL to send the request to. It carries the signature.
+
+        :rtype: ``str``
+        :return: The presigned URL.
+        """
+        pass
+
+    @abstractproperty
+    def headers(self) -> dict[str, str]:
+        """
+        Headers the store requires, which an HTTP client would not send of
+        its own accord.
+
+        :rtype: ``dict``
+        :return: The names and values of the headers to send.
+        """
+        pass
+
+    @abstractproperty
+    def enforces_size(self) -> bool:
+        """
+        Whether the store refuses a body of another size than the request was
+        signed for. Where it doesn't, check the size after the upload.
+
+        :rtype: ``bool``
+        :return: ``True`` if the store enforces the size.
+        """
+        pass
+
+
 class UploadPart(object):
     """
     A handle for a single part uploaded as part of a multipart upload.
 
-    Returned by :meth:`.MultipartUpload.upload_part`. Callers must retain the
-    parts they receive and pass them to :meth:`.MultipartUpload.complete`.
-    The handle is a simple, serializable value object so that parts may be
-    collected across threads or processes when uploading in parallel.
+    Returned by :meth:`.MultipartUpload.upload_part`,
+    :meth:`.MultipartUpload.reported_part` and
+    :meth:`.MultipartUpload.list_parts`. Callers must retain the parts they
+    receive and pass them to :meth:`.MultipartUpload.complete`. The handle is
+    a simple, serializable value object so that parts may be collected across
+    threads or processes when uploading in parallel.
     """
     __metaclass__ = ABCMeta
 
@@ -2229,7 +2285,7 @@ class UploadPart(object):
         Opaque provider handle identifying the stored part.
 
         Its concrete form varies by provider (e.g. an S3 ETag, an Azure block
-        id, a GCS temp-object name, or a Swift segment descriptor) and should
+        id, a GCS part's MD5, or a Swift segment descriptor) and should
         not be interpreted by clients.
 
         :rtype: ``object``
@@ -2237,6 +2293,17 @@ class UploadPart(object):
         """
         pass
 
+    @abstractproperty
+    def size(self) -> int | None:
+        """
+        The size of the part in bytes, where known.
+
+        :rtype: ``int`` or ``None``
+        :return: The part's size, as listed by :meth:`.MultipartUpload.list_parts`;
+            ``None`` for a part reported by its uploader.
+        """
+        pass
+
 
 class MultipartUpload(CloudResource):
     """
@@ -2289,17 +2356,82 @@ class MultipartUpload(CloudResource):
         """
         pass
 
+    @abstractmethod
+    def generate_part_url(self, part_number: int, expires_in: int,
+                          size: int | None = None) -> PresignedRequest:
+        """
+        Generate a request that uploads one part, for a client without
+        credentials.
+
+        The client sends the part with the request and reports the ``ETag``
+        response header back, to be passed to :meth:`reported_part`.
+
+        :type part_number: ``int``
+        :param part_number: 1-based index of the part, as for
+            :meth:`upload_part`.
+
+        :type expires_in: ``int``
+        :param expires_in: Time to live of the request in seconds. The request
+            can be sent again until it expires, replacing the part.
+
+        :type size: ``int``
+        :param size: The part's size in bytes. Where the store can bind it
+            into the signature (see :attr:`.PresignedRequest.enforces_size`),
+            it refuses a part of another size.
+
+        :rtype: :class:`.PresignedRequest`
+        :return: The request that uploads the part.
+        """
+        pass
+
+    @abstractmethod
+    def reported_part(self, part_number: int,
+                      etag: str | None) -> UploadPart:
+        """
+        A handle for a part uploaded through :meth:`generate_part_url`, from
+        what its uploader reported.
+
+        :meth:`complete` refuses the part if the store doesn't hold it, or,
+        where the store keeps a checksum of each part, if the part it holds is
+        not the one that received ``etag``: a part URL can be used again
+        until it expires, to replace the part.
+
+        :type part_number: ``int``
+        :param part_number: 1-based index of the part.
+
+        :type etag: ``str``
+        :param etag: The ``ETag`` response header the part's upload received,
+            as is; ``None`` if it had none.
+
+        :rtype: :class:`.UploadPart`
+        :return: A part handle to pass to :meth:`complete`.
+        """
+        pass
+
+    @abstractmethod
+    def list_parts(self) -> list[UploadPart]:
+        """
+        The parts the store holds for this upload, with their sizes.
+
+        :rtype: ``list`` of :class:`.UploadPart`
+        :return: The uploaded parts, in ascending ``part_number``.
+        """
+        pass
+
     @abstractmethod
     def complete(self, parts: list[UploadPart]) -> BucketObject:
         """
         Finalize the upload, assembling parts in ascending ``part_number``.
 
         :type parts: ``list`` of :class:`.UploadPart`
-        :param parts: The handles returned by :meth:`upload_part`. They may be
-            supplied in any order.
+        :param parts: The handles returned by :meth:`upload_part` or
+            :meth:`reported_part`. They may be supplied in any order.
 
         :rtype: :class:`.BucketObject`
         :return: The completed object.
+
+        :raises InvalidPartException: if the store doesn't hold a reported
+            part as its uploader reported it.
         """
         pass
 

{cloudbridge-4.4.2 → cloudbridge-4.5.0}/cloudbridge/interfaces/services.py

@@ -22,6 +22,7 @@ from cloudbridge.interfaces.resources import MachineImage
 from cloudbridge.interfaces.resources import MultipartUpload
 from cloudbridge.interfaces.resources import Network
 from cloudbridge.interfaces.resources import PageableObjectMixin
+from cloudbridge.interfaces.resources import PresignedRequest
 from cloudbridge.interfaces.resources import Region
 from cloudbridge.interfaces.resources import ResultList
 from cloudbridge.interfaces.resources import Router
@@ -1348,6 +1349,48 @@ class BucketObjectService(CloudService):
         """
         pass
 
+    @abstractmethod
+    def generate_upload_url(self, bucket: Bucket | str, object_name: str,
+                            expires_in: int,
+                            size: int | None) -> PresignedRequest:
+        """
+        Generate a request that uploads an object without credentials.
+
+        See :meth:`.BucketObjectSubService.generate_upload_url`.
+        """
+        pass
+
+    @abstractmethod
+    def generate_part_url(self, bucket: Bucket | str, upload: MultipartUpload,
+                          part_number: int, expires_in: int,
+                          size: int | None) -> PresignedRequest:
+        """
+        Generate a request that uploads one part without credentials.
+
+        See :meth:`.MultipartUpload.generate_part_url`.
+        """
+        pass
+
+    @abstractmethod
+    def reported_part(self, bucket: Bucket | str, upload: MultipartUpload,
+                      part_number: int, etag: str | None) -> UploadPart:
+        """
+        A handle for a part uploaded through a part URL.
+
+        See :meth:`.MultipartUpload.reported_part`.
+        """
+        pass
+
+    @abstractmethod
+    def list_parts(self, bucket: Bucket | str,
+                   upload: MultipartUpload) -> builtins.list[UploadPart]:
+        """
+        The parts the store holds for an upload, with their sizes.
+
+        See :meth:`.MultipartUpload.list_parts`.
+        """
+        pass
+
     @abstractmethod
     def complete_multipart_upload(self, bucket: Bucket | str,
                                   upload: MultipartUpload,

{cloudbridge-4.4.2 → cloudbridge-4.5.0}/cloudbridge/interfaces/subservices.py

@@ -10,7 +10,9 @@ from cloudbridge.interfaces.resources import DnsRecord
 from cloudbridge.interfaces.resources import FloatingIP
 from cloudbridge.interfaces.resources import Gateway
 from cloudbridge.interfaces.resources import InternetGateway
+from cloudbridge.interfaces.resources import MultipartUpload
 from cloudbridge.interfaces.resources import PageableObjectMixin
+from cloudbridge.interfaces.resources import PresignedRequest
 from cloudbridge.interfaces.resources import ResultList
 from cloudbridge.interfaces.resources import Subnet
 from cloudbridge.interfaces.resources import TrafficDirection
@@ -86,6 +88,65 @@ class BucketObjectSubService(PageableObjectMixin[BucketObject]):
         """
         pass
 
+    @abstractmethod
+    def generate_upload_url(self, name: str, expires_in: int,
+                            size: int | None = None) -> PresignedRequest:
+        """
+        Generate a request that uploads an object, new or existing, for a
+        client without credentials.
+
+        Unlike :meth:`.BucketObject.generate_url`, it needs no object to exist
+        first, and creates none.
+
+        :type name: ``str``
+        :param name: The name of the object to upload.
+
+        :type expires_in: ``int``
+        :param expires_in: Time to live of the request in seconds.
+
+        :type size: ``int``
+        :param size: The object's size in bytes. Where the store can bind it
+            into the signature (see :attr:`.PresignedRequest.enforces_size`),
+            it refuses an object of another size.
+
+        :rtype: :class:`.PresignedRequest`
+        :return: The request that uploads the object.
+        """
+        pass
+
+    @abstractmethod
+    def create_multipart_upload(self, name: str) -> MultipartUpload:
+        """
+        Begin a multipart upload of an object, new or existing.
+
+        Unlike :meth:`.BucketObject.create_multipart_upload`, it needs no
+        object to exist first. The object appears once the upload completes.
+
+        :type name: ``str``
+        :param name: The name of the object to upload.
+
+        :rtype: :class:`.MultipartUpload`
+        :return: An in-progress multipart upload handle.
+        """
+        pass
+
+    @abstractmethod
+    def get_multipart_upload(self, name: str,
+                             upload_id: str) -> MultipartUpload:
+        """
+        A handle for an upload begun earlier, possibly by another process.
+
+        :type name: ``str``
+        :param name: The name of the object being uploaded.
+
+        :type upload_id: ``str``
+        :param upload_id: The upload's :attr:`.MultipartUpload.id`.
+
+        :rtype: :class:`.MultipartUpload`
+        :return: The in-progress multipart upload handle.
+        """
+        pass
+
 
 class GatewaySubService(PageableObjectMixin[InternetGateway]):
     """

{cloudbridge-4.4.2 → cloudbridge-4.5.0}/cloudbridge/providers/aws/services.py

@@ -10,12 +10,15 @@ from typing import Any
 from typing import IO
 from typing import TYPE_CHECKING
 from typing import cast
+from urllib.parse import parse_qs
+from urllib.parse import urlparse
 
 from botocore.exceptions import ClientError
 
 import cloudbridge.base.helpers as cb_helpers
 from cloudbridge.base.middleware import dispatch
 from cloudbridge.base.resources import BaseMultipartUpload
+from cloudbridge.base.resources import BasePresignedRequest
 from cloudbridge.base.resources import BaseUploadPart
 from cloudbridge.base.resources import ClientPagedResultList
 from cloudbridge.base.resources import ServerPagedResultList
@@ -47,6 +50,7 @@ from cloudbridge.interfaces.exceptions import DuplicateResourceException
 from cloudbridge.interfaces.exceptions import \
     InvalidConfigurationException
 from cloudbridge.interfaces.exceptions import InvalidParamException
+from cloudbridge.interfaces.exceptions import InvalidPartException
 from cloudbridge.interfaces.exceptions import InvalidValueException
 from cloudbridge.interfaces.exceptions import ProviderInternalException
 from cloudbridge.interfaces.resources import Bucket
@@ -63,6 +67,7 @@ from cloudbridge.interfaces.resources import MachineImage
 from cloudbridge.interfaces.resources import MultipartUpload
 from cloudbridge.interfaces.resources import Network
 from cloudbridge.interfaces.resources import PlacementZone
+from cloudbridge.interfaces.resources import PresignedRequest
 from cloudbridge.interfaces.resources import Region
 from cloudbridge.interfaces.resources import ResultList
 from cloudbridge.interfaces.resources import Router
@@ -706,6 +711,65 @@ class AWSBucketObjectService(BaseBucketObjectService):
             UploadId=upload.id, PartNumber=part_number, Body=data)
         return BaseUploadPart(part_number, response['ETag'])
 
+    def _presigned_put(self, client_method: str, params: dict[str, Any],
+                       expires_in: int,
+                       size: int | None) -> PresignedRequest:
+        if size is not None:
+            params['ContentLength'] = size
+        client = cast("AWSCloudProvider", self.provider).s3_conn.meta.client
+        url = client.generate_presigned_url(client_method, Params=params,
+                                            ExpiresIn=expires_in)
+        # SigV4 signs the size into the URL; SigV2 (s3_signature_version
+        # 's3') signs no headers.
+        signed_headers = parse_qs(urlparse(url).query).get(
+            'X-Amz-SignedHeaders', [''])[0].split(';')
+        return BasePresignedRequest(
+            'PUT', url, enforces_size='content-length' in signed_headers)
+
+    @dispatch(event="provider.storage._bucket_objects.generate_upload_url",
+              priority=BaseBucketObjectService.STANDARD_EVENT_PRIORITY)
+    def generate_upload_url(self, bucket: Bucket | str, object_name: str,
+                            expires_in: int,
+                            size: int | None) -> PresignedRequest:
+        return self._presigned_put(
+            'put_object',
+            {'Bucket': cast(Any, bucket).name, 'Key': object_name},
+            expires_in, size)
+
+    @dispatch(event="provider.storage._bucket_objects.generate_part_url",
+              priority=BaseBucketObjectService.STANDARD_EVENT_PRIORITY)
+    def generate_part_url(self, bucket: Bucket | str, upload: MultipartUpload,
+                          part_number: int, expires_in: int,
+                          size: int | None) -> PresignedRequest:
+        return self._presigned_put(
+            'upload_part',
+            {'Bucket': cast(Any, bucket).name, 'Key': upload.object_name,
+             'UploadId': upload.id, 'PartNumber': part_number},
+            expires_in, size)
+
+    @dispatch(event="provider.storage._bucket_objects.reported_part",
+              priority=BaseBucketObjectService.STANDARD_EVENT_PRIORITY)
+    def reported_part(self, bucket: Bucket | str, upload: MultipartUpload,
+                      part_number: int, etag: str | None) -> UploadPart:
+        if not etag:
+            raise InvalidPartException(
+                "Part {0} of {1} was reported without the ETag S3 returns for"
+                " every part".format(part_number, upload.object_name))
+        # S3 compares the ETag with the part it holds when the upload
+        # completes.
+        return BaseUploadPart(part_number, etag)
+
+    @dispatch(event="provider.storage._bucket_objects.list_parts",
+              priority=BaseBucketObjectService.STANDARD_EVENT_PRIORITY)
+    def list_parts(self, bucket: Bucket | str,
+                   upload: MultipartUpload) -> builtins.list[UploadPart]:
+        client = cast("AWSCloudProvider", self.provider).s3_conn.meta.client
+        pages = client.get_paginator('list_parts').paginate(
+            Bucket=cast(Any, bucket).name, Key=upload.object_name,
+            UploadId=upload.id)
+        return [BaseUploadPart(part['PartNumber'], part['ETag'], part['Size'])
+                for page in pages for part in page.get('Parts', [])]
+
     @dispatch(event="provider.storage._bucket_objects."
                     "complete_multipart_upload",
               priority=BaseBucketObjectService.STANDARD_EVENT_PRIORITY)
@@ -715,12 +779,18 @@ class AWSBucketObjectService(BaseBucketObjectService):
                                   ) -> BucketObject:
         ordered = sorted(parts, key=lambda p: p.part_number)
         client = cast("AWSCloudProvider", self.provider).s3_conn.meta.client
-        client.complete_multipart_upload(
-            Bucket=cast(Any, bucket).name, Key=upload.object_name,
-            UploadId=upload.id,
-            MultipartUpload={'Parts': [
-                {'PartNumber': p.part_number, 'ETag': p.etag}
-                for p in ordered]})
+        try:
+            client.complete_multipart_upload(
+                Bucket=cast(Any, bucket).name, Key=upload.object_name,
+                UploadId=upload.id,
+                MultipartUpload={'Parts': [
+                    {'PartNumber': p.part_number, 'ETag': p.etag}
+                    for p in ordered]})
+        except ClientError as e:
+            # A part S3 doesn't hold, or holds with another ETag.
+            if e.response['Error']['Code'] == 'InvalidPart':
+                raise InvalidPartException(str(e)) from e
+            raise
         # get() may return None, but the completed object is expected to exist.
         return cast(BucketObject, self.get(bucket, upload.object_name))
 

{cloudbridge-4.4.2 → cloudbridge-4.5.0}/cloudbridge/providers/azure/azure_client.py

@@ -498,6 +498,12 @@ class AzureClient(object):
         block_list = [BlobBlock(block_id=block_id) for block_id in block_ids]
         blob_client.commit_block_list(block_list)
 
+    def get_uncommitted_blocks(self, container_name: str,
+                               blob_name: str) -> list[BlobBlock]:
+        blob_client = self.blob_client(container_name, blob_name)
+        _, uncommitted = blob_client.get_block_list('uncommitted')
+        return uncommitted
+
     def get_blob(self, container_name: str, blob_name: str) -> Any:
         blob_client = self.blob_client(container_name, blob_name)
         return blob_client.get_blob_properties(container_name, blob_name)
@@ -517,23 +523,35 @@ class AzureClient(object):
                      expiry_time: int, writable: bool,
                      content_disposition: str | None = None,
                      content_type: str | None = None) -> str:
-        now = datetime.datetime.utcnow()
-        expiry = now + datetime.timedelta(
-            seconds=expiry_time)
-        blob_name = blob_name
-        container_name = container_name.name
+        return self._blob_sas_url(
+            container_name.name, blob_name, expiry_time,
+            BlobSasPermissions(read=True, write=writable),
+            content_disposition=content_disposition,
+            content_type=content_type)
+
+    def get_blob_upload_url(self, container_name: str, blob_name: str,
+                            expiry_time: int) -> str:
+        """
+        A URL that writes the blob, new or existing, or a block of it, until it
+        expires.
+        """
+        return self._blob_sas_url(container_name, blob_name, expiry_time,
+                                  BlobSasPermissions(write=True))
+
+    def _blob_sas_url(self, container_name: str, blob_name: str,
+                      expiry_time: int, permission: BlobSasPermissions,
+                      **sas_options: Any) -> str:
+        now = datetime.datetime.now(datetime.timezone.utc)
+        expiry = now + datetime.timedelta(seconds=expiry_time)
         delegation_key = self.blob_service.get_user_delegation_key(
-            key_start_time=now, key_expiry_time=expiry
-        )
+            key_start_time=now, key_expiry_time=expiry)
         sas = generate_blob_sas(
             self.storage_account, container_name, blob_name,
-            permission=BlobSasPermissions(read=True, write=writable), expiry=expiry,
-            user_delegation_key=delegation_key,
-            content_disposition=content_disposition,
-            content_type=content_type
-        )
-        url = f"https://{self.storage_account}.blob.core.windows.net/{container_name}/{blob_name}?{sas}"
-        return url
+            permission=permission, expiry=expiry,
+            user_delegation_key=delegation_key, **sas_options)
+        # The blob client's URL escapes the blob's name.
+        return "{0}?{1}".format(
+            self.blob_client(container_name, blob_name).url, sas)
 
     def create_empty_disk(self, disk_name: str, params: dict[str, Any]) -> Any:
         return self.compute_client.disks.begin_create_or_update(