@azure/storage-blob 12.13.0-alpha.20230202.2 → 12.13.0

package/dist-esm/storage-blob/src/ContainerClient.js

@@ -1,13 +1,13 @@
 import { __asyncDelegator, __asyncGenerator, __asyncValues, __await } from "tslib";
-import { getDefaultProxySettings, } from "@azure/core-rest-pipeline";
-import { isNode } from "@azure/core-util";
-import { isTokenCredential } from "@azure/core-auth";
+import { getDefaultProxySettings, isNode, isTokenCredential, URLBuilder, } from "@azure/core-http";
+import { SpanStatusCode } from "@azure/core-tracing";
 import { AnonymousCredential } from "./credentials/AnonymousCredential";
 import { StorageSharedKeyCredential } from "./credentials/StorageSharedKeyCredential";
+import { Container } from "./generated/src/operations";
 import { newPipeline, isPipelineLike } from "./Pipeline";
 import { StorageClient } from "./StorageClient";
-import { tracingClient } from "./utils/tracing";
-import { appendToURLPath, appendToURLQuery, assertResponse, BlobNameToString, ConvertInternalResponseOfListBlobFlat, ConvertInternalResponseOfListBlobHierarchy, EscapePath, extractConnectionStringParts, isIpEndpointStyle, parseObjectReplicationRecord, toTags, truncatedISO8061Date, } from "./utils/utils.common";
+import { convertTracingToRequestOptionsBase, createSpan } from "./utils/tracing";
+import { appendToURLPath, appendToURLQuery, BlobNameToString, ConvertInternalResponseOfListBlobFlat, ConvertInternalResponseOfListBlobHierarchy, EscapePath, extractConnectionStringParts, isIpEndpointStyle, parseObjectReplicationRecord, toTags, truncatedISO8061Date, } from "./utils/utils.common";
 import { generateBlobSASQueryParameters } from "./sas/BlobSASSignatureValues";
 import { BlobLeaseClient } from "./BlobLeaseClient";
 import { AppendBlobClient, BlobClient, BlockBlobClient, PageBlobClient, } from "./Clients";
@@ -76,7 +76,7 @@ export class ContainerClient extends StorageClient {
         }
         super(url, pipeline);
         this._containerName = this.getContainerNameFromUrl();
-        this.containerContext = this.storageClientContext.container;
+        this.containerContext = new Container(this.storageClientContext);
     }
     /**
      * The name of the container.
@@ -102,9 +102,22 @@ export class ContainerClient extends StorageClient {
      * ```
      */
     async create(options = {}) {
-        return tracingClient.withSpan("ContainerClient-create", options, async (updatedOptions) => {
-            return assertResponse(await this.containerContext.create(updatedOptions));
-        });
+        const { span, updatedOptions } = createSpan("ContainerClient-create", options);
+        try {
+            // Spread operator in destructuring assignments,
+            // this will filter out unwanted properties from the response object into result object
+            return await this.containerContext.create(Object.assign(Object.assign({}, options), convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Creates a new container under the specified account. If the container with
@@ -115,21 +128,29 @@ export class ContainerClient extends StorageClient {
      * @param options -
      */
     async createIfNotExists(options = {}) {
-        return tracingClient.withSpan("ContainerClient-createIfNotExists", options, async (updatedOptions) => {
-            var _a, _b;
-            try {
-                const res = await this.create(updatedOptions);
-                return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
-            }
-            catch (e) {
-                if (((_a = e.details) === null || _a === void 0 ? void 0 : _a.errorCode) === "ContainerAlreadyExists") {
-                    return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === void 0 ? void 0 : _b.parsedHeaders), { _response: e.response });
-                }
-                else {
-                    throw e;
-                }
+        var _a, _b;
+        const { span, updatedOptions } = createSpan("ContainerClient-createIfNotExists", options);
+        try {
+            const res = await this.create(updatedOptions);
+            return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
+        }
+        catch (e) {
+            if (((_a = e.details) === null || _a === void 0 ? void 0 : _a.errorCode) === "ContainerAlreadyExists") {
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: "Expected exception when creating a container only if it does not already exist.",
+                });
+                return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === void 0 ? void 0 : _b.parsedHeaders), { _response: e.response });
             }
-        });
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Returns true if the Azure container resource represented by this client exists; false otherwise.
@@ -141,21 +162,31 @@ export class ContainerClient extends StorageClient {
      * @param options -
      */
     async exists(options = {}) {
-        return tracingClient.withSpan("ContainerClient-exists", options, async (updatedOptions) => {
-            try {
-                await this.getProperties({
-                    abortSignal: options.abortSignal,
-                    tracingOptions: updatedOptions.tracingOptions,
+        const { span, updatedOptions } = createSpan("ContainerClient-exists", options);
+        try {
+            await this.getProperties({
+                abortSignal: options.abortSignal,
+                tracingOptions: updatedOptions.tracingOptions,
+            });
+            return true;
+        }
+        catch (e) {
+            if (e.statusCode === 404) {
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: "Expected exception when checking container existence",
                 });
-                return true;
+                return false;
             }
-            catch (e) {
-                if (e.statusCode === 404) {
-                    return false;
-                }
-                throw e;
-            }
-        });
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Creates a {@link BlobClient}
@@ -216,9 +247,20 @@ export class ContainerClient extends StorageClient {
         if (!options.conditions) {
             options.conditions = {};
         }
-        return tracingClient.withSpan("ContainerClient-getProperties", options, async (updatedOptions) => {
-            return assertResponse(await this.containerContext.getProperties(Object.assign(Object.assign({ abortSignal: options.abortSignal }, options.conditions), { tracingOptions: updatedOptions.tracingOptions })));
-        });
+        const { span, updatedOptions } = createSpan("ContainerClient-getProperties", options);
+        try {
+            return await this.containerContext.getProperties(Object.assign(Object.assign({ abortSignal: options.abortSignal }, options.conditions), convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Marks the specified container for deletion. The container and any blobs
@@ -231,14 +273,20 @@ export class ContainerClient extends StorageClient {
         if (!options.conditions) {
             options.conditions = {};
         }
-        return tracingClient.withSpan("ContainerClient-delete", options, async (updatedOptions) => {
-            return assertResponse(await this.containerContext.delete({
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: options.conditions,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        const { span, updatedOptions } = createSpan("ContainerClient-delete", options);
+        try {
+            return await this.containerContext.delete(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: options.conditions }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Marks the specified container for deletion if it exists. The container and any blobs
@@ -248,19 +296,29 @@ export class ContainerClient extends StorageClient {
      * @param options - Options to Container Delete operation.
      */
     async deleteIfExists(options = {}) {
-        return tracingClient.withSpan("ContainerClient-deleteIfExists", options, async (updatedOptions) => {
-            var _a, _b;
-            try {
-                const res = await this.delete(updatedOptions);
-                return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
-            }
-            catch (e) {
-                if (((_a = e.details) === null || _a === void 0 ? void 0 : _a.errorCode) === "ContainerNotFound") {
-                    return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === void 0 ? void 0 : _b.parsedHeaders), { _response: e.response });
-                }
-                throw e;
+        var _a, _b;
+        const { span, updatedOptions } = createSpan("ContainerClient-deleteIfExists", options);
+        try {
+            const res = await this.delete(updatedOptions);
+            return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
+        }
+        catch (e) {
+            if (((_a = e.details) === null || _a === void 0 ? void 0 : _a.errorCode) === "ContainerNotFound") {
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: "Expected exception when deleting a container only if it exists.",
+                });
+                return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === void 0 ? void 0 : _b.parsedHeaders), { _response: e.response });
             }
-        });
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Sets one or more user-defined name-value pairs for the specified container.
@@ -281,15 +339,20 @@ export class ContainerClient extends StorageClient {
         if (options.conditions.ifUnmodifiedSince) {
             throw new RangeError("the IfUnmodifiedSince must have their default values because they are ignored by the blob service");
         }
-        return tracingClient.withSpan("ContainerClient-setMetadata", options, async (updatedOptions) => {
-            return assertResponse(await this.containerContext.setMetadata({
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                metadata,
-                modifiedAccessConditions: options.conditions,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        const { span, updatedOptions } = createSpan("ContainerClient-setMetadata", options);
+        try {
+            return await this.containerContext.setMetadata(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, metadata, modifiedAccessConditions: options.conditions }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Gets the permissions for the specified container. The permissions indicate
@@ -306,12 +369,9 @@ export class ContainerClient extends StorageClient {
         if (!options.conditions) {
             options.conditions = {};
         }
-        return tracingClient.withSpan("ContainerClient-getAccessPolicy", options, async (updatedOptions) => {
-            const response = assertResponse(await this.containerContext.getAccessPolicy({
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
+        const { span, updatedOptions } = createSpan("ContainerClient-getAccessPolicy", options);
+        try {
+            const response = await this.containerContext.getAccessPolicy(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions }, convertTracingToRequestOptionsBase(updatedOptions)));
             const res = {
                 _response: response._response,
                 blobPublicAccess: response.blobPublicAccess,
@@ -343,7 +403,17 @@ export class ContainerClient extends StorageClient {
                 });
             }
             return res;
-        });
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Sets the permissions for the specified container. The permissions indicate
@@ -364,7 +434,8 @@ export class ContainerClient extends StorageClient {
      */
     async setAccessPolicy(access, containerAcl, options = {}) {
         options.conditions = options.conditions || {};
-        return tracingClient.withSpan("ContainerClient-setAccessPolicy", options, async (updatedOptions) => {
+        const { span, updatedOptions } = createSpan("ContainerClient-setAccessPolicy", options);
+        try {
             const acl = [];
             for (const identifier of containerAcl || []) {
                 acl.push({
@@ -380,15 +451,18 @@ export class ContainerClient extends StorageClient {
                     id: identifier.id,
                 });
             }
-            return assertResponse(await this.containerContext.setAccessPolicy({
-                abortSignal: options.abortSignal,
-                access,
-                containerAcl: acl,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: options.conditions,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+            return await this.containerContext.setAccessPolicy(Object.assign({ abortSignal: options.abortSignal, access, containerAcl: acl, leaseAccessConditions: options.conditions, modifiedAccessConditions: options.conditions }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Get a {@link BlobLeaseClient} that manages leases on the container.
@@ -422,14 +496,25 @@ export class ContainerClient extends StorageClient {
      * @returns Block Blob upload response data and the corresponding BlockBlobClient instance.
      */
     async uploadBlockBlob(blobName, body, contentLength, options = {}) {
-        return tracingClient.withSpan("ContainerClient-uploadBlockBlob", options, async (updatedOptions) => {
+        const { span, updatedOptions } = createSpan("ContainerClient-uploadBlockBlob", options);
+        try {
             const blockBlobClient = this.getBlockBlobClient(blobName);
             const response = await blockBlobClient.upload(body, contentLength, updatedOptions);
             return {
                 blockBlobClient,
                 response,
             };
-        });
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Marks the specified blob or snapshot for deletion. The blob is later deleted
@@ -443,13 +528,24 @@ export class ContainerClient extends StorageClient {
      * @returns Block blob deletion response data.
      */
     async deleteBlob(blobName, options = {}) {
-        return tracingClient.withSpan("ContainerClient-deleteBlob", options, async (updatedOptions) => {
+        const { span, updatedOptions } = createSpan("ContainerClient-deleteBlob", options);
+        try {
             let blobClient = this.getBlobClient(blobName);
             if (options.versionId) {
                 blobClient = blobClient.withVersion(options.versionId);
             }
-            return blobClient.delete(updatedOptions);
-        });
+            return await blobClient.delete(updatedOptions);
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * listBlobFlatSegment returns a single segment of blobs starting from the
@@ -462,14 +558,25 @@ export class ContainerClient extends StorageClient {
      * @param options - Options to Container List Blob Flat Segment operation.
      */
     async listBlobFlatSegment(marker, options = {}) {
-        return tracingClient.withSpan("ContainerClient-listBlobFlatSegment", options, async (updatedOptions) => {
-            const response = assertResponse(await this.containerContext.listBlobFlatSegment(Object.assign(Object.assign({ marker }, options), { tracingOptions: updatedOptions.tracingOptions })));
-            const wrappedResponse = Object.assign(Object.assign({}, response), { _response: Object.assign(Object.assign({}, response._response), { parsedBody: ConvertInternalResponseOfListBlobFlat(response._response.parsedBody) }), segment: Object.assign(Object.assign({}, response.segment), { blobItems: response.segment.blobItems.map((blobItemInternal) => {
-                        const blobItem = Object.assign(Object.assign({}, blobItemInternal), { name: BlobNameToString(blobItemInternal.name), tags: toTags(blobItemInternal.blobTags), objectReplicationSourceProperties: parseObjectReplicationRecord(blobItemInternal.objectReplicationMetadata) });
+        const { span, updatedOptions } = createSpan("ContainerClient-listBlobFlatSegment", options);
+        try {
+            const response = await this.containerContext.listBlobFlatSegment(Object.assign(Object.assign({ marker }, options), convertTracingToRequestOptionsBase(updatedOptions)));
+            const wrappedResponse = Object.assign(Object.assign({}, response), { _response: Object.assign(Object.assign({}, response._response), { parsedBody: ConvertInternalResponseOfListBlobFlat(response._response.parsedBody) }), segment: Object.assign(Object.assign({}, response.segment), { blobItems: response.segment.blobItems.map((blobItemInteral) => {
+                        const blobItem = Object.assign(Object.assign({}, blobItemInteral), { name: BlobNameToString(blobItemInteral.name), tags: toTags(blobItemInteral.blobTags), objectReplicationSourceProperties: parseObjectReplicationRecord(blobItemInteral.objectReplicationMetadata) });
                         return blobItem;
                     }) }) });
             return wrappedResponse;
-        });
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * listBlobHierarchySegment returns a single segment of blobs starting from
@@ -483,11 +590,12 @@ export class ContainerClient extends StorageClient {
      * @param options - Options to Container List Blob Hierarchy Segment operation.
      */
     async listBlobHierarchySegment(delimiter, marker, options = {}) {
-        return tracingClient.withSpan("ContainerClient-listBlobHierarchySegment", options, async (updatedOptions) => {
-            var _a;
-            const response = assertResponse(await this.containerContext.listBlobHierarchySegment(delimiter, Object.assign(Object.assign({ marker }, options), { tracingOptions: updatedOptions.tracingOptions })));
-            const wrappedResponse = Object.assign(Object.assign({}, response), { _response: Object.assign(Object.assign({}, response._response), { parsedBody: ConvertInternalResponseOfListBlobHierarchy(response._response.parsedBody) }), segment: Object.assign(Object.assign({}, response.segment), { blobItems: response.segment.blobItems.map((blobItemInternal) => {
-                        const blobItem = Object.assign(Object.assign({}, blobItemInternal), { name: BlobNameToString(blobItemInternal.name), tags: toTags(blobItemInternal.blobTags), objectReplicationSourceProperties: parseObjectReplicationRecord(blobItemInternal.objectReplicationMetadata) });
+        var _a;
+        const { span, updatedOptions } = createSpan("ContainerClient-listBlobHierarchySegment", options);
+        try {
+            const response = await this.containerContext.listBlobHierarchySegment(delimiter, Object.assign(Object.assign({ marker }, options), convertTracingToRequestOptionsBase(updatedOptions)));
+            const wrappedResponse = Object.assign(Object.assign({}, response), { _response: Object.assign(Object.assign({}, response._response), { parsedBody: ConvertInternalResponseOfListBlobHierarchy(response._response.parsedBody) }), segment: Object.assign(Object.assign({}, response.segment), { blobItems: response.segment.blobItems.map((blobItemInteral) => {
+                        const blobItem = Object.assign(Object.assign({}, blobItemInteral), { name: BlobNameToString(blobItemInteral.name), tags: toTags(blobItemInteral.blobTags), objectReplicationSourceProperties: parseObjectReplicationRecord(blobItemInteral.objectReplicationMetadata) });
                         return blobItem;
                     }), blobPrefixes: (_a = response.segment.blobPrefixes) === null || _a === void 0 ? void 0 : _a.map((blobPrefixInternal) => {
                         const blobPrefix = {
@@ -496,7 +604,17 @@ export class ContainerClient extends StorageClient {
                         return blobPrefix;
                     }) }) });
             return wrappedResponse;
-        });
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Returns an AsyncIterableIterator for ContainerListBlobFlatSegmentResponse
@@ -891,14 +1009,9 @@ export class ContainerClient extends StorageClient {
      * @param options - Options to find blobs by tags.
      */
     async findBlobsByTagsSegment(tagFilterSqlExpression, marker, options = {}) {
-        return tracingClient.withSpan("ContainerClient-findBlobsByTagsSegment", options, async (updatedOptions) => {
-            const response = assertResponse(await this.containerContext.filterBlobs({
-                abortSignal: options.abortSignal,
-                where: tagFilterSqlExpression,
-                marker,
-                maxPageSize: options.maxPageSize,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
+        const { span, updatedOptions } = createSpan("ContainerClient-findBlobsByTagsSegment", options);
+        try {
+            const response = await this.containerContext.filterBlobs(Object.assign({ abortSignal: options.abortSignal, where: tagFilterSqlExpression, marker, maxPageSize: options.maxPageSize }, convertTracingToRequestOptionsBase(updatedOptions)));
             const wrappedResponse = Object.assign(Object.assign({}, response), { _response: response._response, blobs: response.blobs.map((blob) => {
                     var _a;
                     let tagValue = "";
@@ -908,7 +1021,17 @@ export class ContainerClient extends StorageClient {
                     return Object.assign(Object.assign({}, blob), { tags: toTags(blob.tags), tagValue });
                 }) });
             return wrappedResponse;
-        });
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Returns an AsyncIterableIterator for ContainerFindBlobsByTagsSegmentResponse.
@@ -1077,23 +1200,23 @@ export class ContainerClient extends StorageClient {
             // "https://myaccount.blob.core.windows.net/mycontainer";
             // IPv4/IPv6 address hosts, Endpoints - `http://127.0.0.1:10000/devstoreaccount1/containername`
             // http://localhost:10001/devstoreaccount1/containername
-            const parsedUrl = new URL(this.url);
-            if (parsedUrl.hostname.split(".")[1] === "blob") {
+            const parsedUrl = URLBuilder.parse(this.url);
+            if (parsedUrl.getHost().split(".")[1] === "blob") {
                 // "https://myaccount.blob.core.windows.net/containername".
                 // "https://customdomain.com/containername".
                 // .getPath() -> /containername
-                containerName = parsedUrl.pathname.split("/")[1];
+                containerName = parsedUrl.getPath().split("/")[1];
             }
             else if (isIpEndpointStyle(parsedUrl)) {
                 // IPv4/IPv6 address hosts... Example - http://192.0.0.10:10001/devstoreaccount1/containername
                 // Single word domain without a [dot] in the endpoint... Example - http://localhost:10001/devstoreaccount1/containername
                 // .getPath() -> /devstoreaccount1/containername
-                containerName = parsedUrl.pathname.split("/")[2];
+                containerName = parsedUrl.getPath().split("/")[2];
             }
             else {
                 // "https://customdomain.com/containername".
                 // .getPath() -> /containername
-                containerName = parsedUrl.pathname.split("/")[1];
+                containerName = parsedUrl.getPath().split("/")[1];
             }
             // decode the encoded containerName - to get all the special characters that might be present in it
             containerName = decodeURIComponent(containerName);