@azure/core-amqp 2.2.0-alpha.20210326.1 → 3.0.0

package/CHANGELOG.md

@@ -1,6 +1,19 @@
 # Release History
 
-## 2.2.0 (Unreleased)
+## 3.0.0 (2021-06-09)
+
+### Breaking changes
+
+- Updates the `rhea-promise` and `rhea` dependencies to version 2.x. `rhea` contains a breaking change that changes deserialization of timestamps from numbers to Date objects.
+- Removes the `AsyncLock` and `defaultLock` exports. `defaultCancellableLock` should be used instead.
+
+## 2.3.0 (2021-04-29)
+
+- Updates `AmqpAnnotatedMessage` to identify the AMQP section where body data was decoded from. [PR 14703](https://github.com/Azure/azure-sdk-for-js/pull/14703).
+
+- Adds `CancellableAsyncLock` as an alternative to `AsyncLock` that supports cancellation via the abort signal. [PR 14844](https://github.com/Azure/azure-sdk-for-js/pull/14844).
+
+## 2.2.0 (2021-03-30)
 
 - Updates `translateError` to convert non-object type parameters to errors.
   The parameter will be part of the error's `message` property unless the parameter is null or undefined.
@@ -11,6 +24,7 @@
   - CbsClient.init()
   - CbsClient.negotiateClaim()
   - RequestResponseLink.create()
+- Exporting `StandardAbortMessage` that is the standard error message accompanying the `AbortError`.
 
 ## 2.1.0 (2021-02-08)
 
@@ -138,7 +152,7 @@ We are cleaning the public API surface by
 - Updated to use the latest version of the `rhea` package.
   This update improves support for [bundling](https://github.com/Azure/azure-sdk-for-js/blob/master/documentation/Bundling.md) this library.
 
-## 1.0.0 (2019-01-08)
+## 1.0.0 (2020-01-08)
 
 - This release marks the general availability of the `@azure/core-amqp` package.
 - Improved detection of when an established socket is no longer receiving data from the service.

package/dist/index.js

@@ -7,10 +7,11 @@ function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'defau
 var tslib = require('tslib');
 var abortController = require('@azure/abort-controller');
 var rheaPromise = require('rhea-promise');
-var AsyncLock = _interopDefault(require('async-lock'));
 var logger$1 = require('@azure/logger');
 var dns = require('dns');
 var os = require('os');
+var coreAuth = require('@azure/core-auth');
+var jssha = _interopDefault(require('jssha'));
 
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
@@ -173,6 +174,190 @@ function isObjectWithProperties(thing, properties) {
 function objectHasProperty(thing, property) {
     return typeof thing === "object" && property in thing;
 }
+/**
+ * Typeguard that checks if the input is a SasTokenProvider.
+ * @param thing - Any object.
+ * @hidden
+ */
+function isSasTokenProvider(thing) {
+    return isObjectWithProperties(thing, ["isSasTokenProvider"]) && thing.isSasTokenProvider === true;
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * The \@azure/logger configuration for this package.
+ * This will output logs using the `azure:event-hubs` namespace prefix.
+ */
+const logger = logger$1.createClientLogger("core-amqp");
+/**
+ * Logs the error's stack trace to "verbose" if a stack trace is available.
+ * @param error - Error containing a stack trace.
+ * @internal
+ */
+function logErrorStackTrace(error) {
+    if (isObjectWithProperties(error, ["stack"])) {
+        logger.verbose(error.stack);
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * This class is used to coordinate executing tasks that should not be run in parallel.
+ * @internal
+ */
+class CancellableAsyncLockImpl {
+    constructor() {
+        this._keyMap = new Map();
+        this._executionRunningSet = new Set();
+    }
+    /**
+     * Returns a promise that resolves to the value returned by the provided task function.
+     * Only 1 task can be invoked at a time for a given `key` value.
+     *
+     * An acquire call can be cancelled via an `abortSignal`.
+     * If cancelled, the promise will be rejected with an `AbortError`.
+     *
+     * `acquireTimeoutInMs` can also be provided to properties.
+     * If the timeout is reached before the provided `task` is invoked,
+     * then the promise will be rejected with an Error stating the task
+     * timed out waiting to acquire a lock.
+     *
+     * @param key - All `acquire` calls are grouped by the provided `key`.
+     * @param task - The function to invoke once the lock has been acquired.
+     * @param properties - Additional properties to control the behavior of `acquire`.
+     */
+    acquire(key, task, properties) {
+        var _a;
+        const { abortSignal, timeoutInMs } = properties;
+        // Fast exit if the operation is already cancelled.
+        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+            return Promise.reject(new abortController.AbortError(StandardAbortMessage));
+        }
+        // Ensure we've got a task queue for the given key.
+        const taskQueue = (_a = this._keyMap.get(key)) !== null && _a !== void 0 ? _a : [];
+        this._keyMap.set(key, taskQueue);
+        // This method will return a promise that will be fulfilled outside this function.
+        const { promise, rejecter, resolver } = getPromiseParts();
+        const taskDetails = {
+            reject: rejecter,
+            resolve: resolver,
+            task
+        };
+        // Handle timeouts by removing the task from the queue when hit.
+        if (typeof timeoutInMs === "number") {
+            const tid = setTimeout(() => {
+                this._removeTaskDetails(key, taskDetails);
+                rejecter(new rheaPromise.OperationTimeoutError(`The task timed out waiting to acquire a lock for ${key}`));
+            }, timeoutInMs);
+            taskDetails.tid = tid;
+        }
+        // Handle cancellation by removing the task from the queue when cancelled.
+        if (abortSignal) {
+            const abortListener = () => {
+                this._removeTaskDetails(key, taskDetails);
+                rejecter(new abortController.AbortError(StandardAbortMessage));
+            };
+            abortSignal.addEventListener("abort", abortListener);
+            taskDetails.abortSignal = abortSignal;
+            taskDetails.abortListener = abortListener;
+        }
+        // Enqueue the task!
+        taskQueue.push(taskDetails);
+        logger.verbose(`Called acquire() for lock "${key}". Lock "${key}" has ${taskQueue.length} pending tasks.`);
+        // Start a loop to iterate over the task queue.
+        // This will run asynchronously and won't allow
+        // more than 1 concurrent execution per key at a time.
+        this._execute(key);
+        return promise;
+    }
+    /**
+     * Iterates over all the pending tasks for a given `key` serially.
+     *
+     * Note: If the pending tasks are already being iterated by an early
+     * _execute invocation, this returns immediately.
+     * @returns
+     */
+    _execute(key) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            // If the key already exists in the set, then exit because
+            // tasks are already being processed.
+            if (this._executionRunningSet.has(key)) {
+                return;
+            }
+            const taskQueue = this._keyMap.get(key);
+            // If the queue is empty, exit early!
+            if (!taskQueue || !taskQueue.length) {
+                return;
+            }
+            // Add the key to the set so we can tell the
+            // task queue is already being processed.
+            this._executionRunningSet.add(key);
+            while (taskQueue.length) {
+                // Remove tasks from the front of the queue.
+                // Order matters!
+                const taskDetails = taskQueue.shift();
+                if (!taskDetails) {
+                    continue;
+                }
+                try {
+                    logger.verbose(`Acquired lock for "${key}", invoking task.`);
+                    cleanupTaskDetails(taskDetails);
+                    const value = yield taskDetails.task();
+                    taskDetails.resolve(value);
+                }
+                catch (err) {
+                    taskDetails.reject(err);
+                }
+                logger.verbose(`Task completed for lock "${key}". Lock "${key}" has ${taskQueue.length} pending tasks.`);
+            }
+            // Indicate that the task queue for the key is empty
+            // and we're done processing it.
+            this._executionRunningSet.delete(key);
+        });
+    }
+    _removeTaskDetails(key, taskDetails) {
+        const taskQueue = this._keyMap.get(key);
+        if (!taskQueue || !taskQueue.length) {
+            // The task is already gone from the queue, so our work here is done!
+            return;
+        }
+        const index = taskQueue.indexOf(taskDetails);
+        if (index !== -1) {
+            const [details] = taskQueue.splice(index, 1);
+            // Cleanup the task rejection code paths.
+            cleanupTaskDetails(details);
+        }
+    }
+}
+/**
+ * @internal
+ * Returns a promise and the promise's resolve and reject methods.
+ */
+function getPromiseParts() {
+    let resolver;
+    let rejecter;
+    const promise = new Promise((resolve, reject) => {
+        resolver = resolve;
+        rejecter = reject;
+    });
+    return {
+        promise,
+        resolver: resolver,
+        rejecter: rejecter
+    };
+}
+/**
+ * @internal
+ * Removes any abort listener or pending timeout from a task.
+ */
+function cleanupTaskDetails(taskDetails) {
+    // Cleanup the task rejection code paths.
+    if (taskDetails.tid)
+        clearTimeout(taskDetails.tid);
+    if (taskDetails.abortSignal && taskDetails.abortListener) {
+        taskDetails.abortSignal.removeEventListener("abort", taskDetails.abortListener);
+    }
+}
 
 // Copyright (c) Microsoft Corporation.
 /**
@@ -218,9 +403,9 @@ function parseConnectionString(connectionString) {
     return output;
 }
 /**
- * The async lock instance with default settings.
+ * The cancellable async lock instance.
  */
-const defaultLock = new AsyncLock({ maxPending: 10000 });
+const defaultCancellableLock = new CancellableAsyncLockImpl();
 /**
  * A wrapper for setTimeout that resolves a promise after t milliseconds.
  * @param delayInMs - The number of milliseconds to be delayed.
@@ -234,7 +419,7 @@ function delay(delayInMs, abortSignal, abortErrorMsg, value) {
         let timer = undefined;
         let onAborted = undefined;
         const rejectOnAbort = () => {
-            return reject(new abortController.AbortError(abortErrorMsg ? abortErrorMsg : `The delay was cancelled by the user.`));
+            return reject(new abortController.AbortError(abortErrorMsg ? abortErrorMsg : StandardAbortMessage));
         };
         const removeListeners = () => {
             if (abortSignal && onAborted) {
@@ -274,6 +459,11 @@ function isNumber(n) {
 }
 
 // Copyright (c) Microsoft Corporation.
+/**
+ * The standard error message accompanying an AbortError.
+ * @hidden
+ */
+const StandardAbortMessage = "The operation was aborted.";
 /**
  * Maps the conditions to the numeric AMQP Response status codes.
  * @internal
@@ -757,6 +947,9 @@ const retryableErrors = [
     "ServerBusyError",
     "ServiceUnavailableError",
     "OperationCancelledError",
+    // The service may throw UnauthorizedError if credentials have been rotated.
+    // Attempt to retry in case the user has also rotated their credentials.
+    "UnauthorizedError",
     // OperationTimeoutError occurs when the service fails to respond within a given timeframe.
     // Since reasons for such failures can be transient, this is treated as a retryable error.
     "OperationTimeoutError",
@@ -912,23 +1105,6 @@ function isAmqpError(error) {
     return rheaPromise.isAmqpError(error);
 }
 
-// Copyright (c) Microsoft Corporation.
-/**
- * The \@azure/logger configuration for this package.
- * This will output logs using the `azure:event-hubs` namespace prefix.
- */
-const logger = logger$1.createClientLogger("core-amqp");
-/**
- * Logs the error's stack trace to "verbose" if a stack trace is available.
- * @param error - Error containing a stack trace.
- * @internal
- */
-function logErrorStackTrace(error) {
-    if (isObjectWithProperties(error, ["stack"])) {
-        logger.verbose(error.stack);
-    }
-}
-
 // Copyright (c) Microsoft Corporation.
 /**
  * Describes an amqp request(sender)-response(receiver) link that is created over an amqp session.
@@ -996,7 +1172,7 @@ class RequestResponseLink {
                     `to "${address}" has been cancelled by the user.`;
                 // Cancellation is a user-intended action, so log to info instead of warning.
                 logger.info(desc);
-                const error = new abortController.AbortError(`The ${requestName ? requestName + " " : ""}operation has been cancelled by the user.`);
+                const error = new abortController.AbortError(StandardAbortMessage);
                 reject(error);
             };
             const onAbort = () => {
@@ -1206,6 +1382,7 @@ function isDelivery(obj) {
     RetryOperationType["sendMessage"] = "sendMessage";
     RetryOperationType["receiveMessage"] = "receiveMessage";
     RetryOperationType["session"] = "session";
+    RetryOperationType["messageSettlement"] = "settlement";
 })(exports.RetryOperationType || (exports.RetryOperationType = {}));
 /**
  * Validates the retry config.
@@ -1439,20 +1616,19 @@ class CbsClient {
      */
     init(options = {}) {
         return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { abortSignal } = options;
-            const initAbortMessage = "The init operation has been cancelled by the user.";
+            const { abortSignal, timeoutInMs } = options;
             try {
                 if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
-                    throw new abortController.AbortError(initAbortMessage);
+                    throw new abortController.AbortError(StandardAbortMessage);
                 }
                 // Acquire the lock and establish an amqp connection if it does not exist.
                 if (!this.connection.isOpen()) {
                     logger.verbose("The CBS client is trying to establish an AMQP connection.");
-                    yield defaultLock.acquire(this.connectionLock, () => {
+                    yield defaultCancellableLock.acquire(this.connectionLock, () => {
                         return this.connection.open({ abortSignal });
-                    });
+                    }, { abortSignal: abortSignal, timeoutInMs: timeoutInMs });
                 }
-                if (!this._isCbsSenderReceiverLinkOpen()) {
+                if (!this.isOpen()) {
                     const rxOpt = {
                         source: {
                             address: this.endpoint
@@ -1530,10 +1706,10 @@ class CbsClient {
      */
     negotiateClaim(audience, token, tokenType, options = {}) {
         return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { abortSignal } = options;
+            const { abortSignal, timeoutInMs } = options;
             try {
                 if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
-                    throw new abortController.AbortError("The negotiateClaim operation has been cancelled by the user.");
+                    throw new abortController.AbortError(StandardAbortMessage);
                 }
                 if (!this._cbsSenderReceiverLink) {
                     throw new Error("Attempted to negotiate a claim but the CBS link does not exist.");
@@ -1551,6 +1727,7 @@ class CbsClient {
                 };
                 const responseMessage = yield this._cbsSenderReceiverLink.sendRequest(request, {
                     abortSignal,
+                    timeoutInMs,
                     requestName: "negotiateClaim"
                 });
                 logger.verbose("[%s] The CBS response is: %O", this.connection.id, responseMessage);
@@ -1571,7 +1748,7 @@ class CbsClient {
     close() {
         return tslib.__awaiter(this, void 0, void 0, function* () {
             try {
-                if (this._isCbsSenderReceiverLinkOpen()) {
+                if (this.isOpen()) {
                     const cbsLink = this._cbsSenderReceiverLink;
                     this._cbsSenderReceiverLink = undefined;
                     yield cbsLink.close();
@@ -1610,8 +1787,9 @@ class CbsClient {
      * Indicates whether the cbs sender receiver link is open or closed.
      * @returns `true` open, `false` closed.
      */
-    _isCbsSenderReceiverLinkOpen() {
-        return this._cbsSenderReceiverLink && this._cbsSenderReceiverLink.isOpen();
+    isOpen() {
+        var _a;
+        return Boolean((_a = this._cbsSenderReceiverLink) === null || _a === void 0 ? void 0 : _a.isOpen());
     }
     _fromRheaMessageResponse(msg) {
         const cbsResponse = {
@@ -1699,7 +1877,7 @@ const AmqpMessageProperties = {
     toRheaMessageProperties(props) {
         const amqpProperties = {};
         if (props.absoluteExpiryTime != undefined) {
-            amqpProperties.absolute_expiry_time = props.absoluteExpiryTime;
+            amqpProperties.absolute_expiry_time = new Date(props.absoluteExpiryTime);
         }
         if (props.contentEncoding != undefined) {
             amqpProperties.content_encoding = props.contentEncoding;
@@ -1711,7 +1889,7 @@ const AmqpMessageProperties = {
             amqpProperties.correlation_id = props.correlationId;
         }
         if (props.creationTime != undefined) {
-            amqpProperties.creation_time = props.creationTime;
+            amqpProperties.creation_time = new Date(props.creationTime);
         }
         if (props.groupId != undefined) {
             amqpProperties.group_id = props.groupId;
@@ -1748,7 +1926,7 @@ const AmqpMessageProperties = {
     fromRheaMessageProperties(props) {
         const msgProperties = {};
         if (props.absolute_expiry_time != undefined) {
-            msgProperties.absoluteExpiryTime = props.absolute_expiry_time;
+            msgProperties.absoluteExpiryTime = props.absolute_expiry_time.getTime();
         }
         if (props.content_encoding != undefined) {
             msgProperties.contentEncoding = props.content_encoding;
@@ -1760,7 +1938,7 @@ const AmqpMessageProperties = {
             msgProperties.correlationId = props.correlation_id;
         }
         if (props.creation_time != undefined) {
-            msgProperties.creationTime = props.creation_time;
+            msgProperties.creationTime = props.creation_time.getTime();
         }
         if (props.group_id != undefined) {
             msgProperties.groupId = props.group_id;
@@ -1902,10 +2080,91 @@ const AmqpAnnotatedMessage = {
             properties: AmqpMessageProperties.fromRheaMessageProperties(msg),
             body: msg.body
         };
+    },
+    /**
+     * Takes AmqpAnnotatedMessage and returns it in the RheaMessage(`Message` type from "rhea") format.
+     */
+    toRheaMessage(msg) {
+        const message = Object.assign(Object.assign(Object.assign({}, AmqpMessageProperties.toRheaMessageProperties(msg.properties || {})), AmqpMessageHeader.toRheaMessageHeader(msg.header || {})), { body: msg.body, message_annotations: msg.messageAnnotations, delivery_annotations: msg.deliveryAnnotations, application_properties: msg.applicationProperties, footer: msg.footer });
+        return message;
     }
 };
 
-exports.AsyncLock = AsyncLock;
+// Copyright (c) Microsoft Corporation.
+/**
+ * Creates a token provider from the provided shared access data.
+ * @param data - The sharedAccessKeyName/sharedAccessKey pair or the sharedAccessSignature.
+ * @hidden
+ */
+function createSasTokenProvider(data) {
+    if (coreAuth.isNamedKeyCredential(data) || coreAuth.isSASCredential(data)) {
+        return new SasTokenProviderImpl(data);
+    }
+    else if (isObjectWithProperties(data, ["sharedAccessKeyName", "sharedAccessKey"])) {
+        return new SasTokenProviderImpl({ name: data.sharedAccessKeyName, key: data.sharedAccessKey });
+    }
+    else {
+        return new SasTokenProviderImpl({ signature: data.sharedAccessSignature });
+    }
+}
+/**
+ * A TokenProvider that generates a Sas token:
+ * `SharedAccessSignature sr=<resource>&sig=<signature>&se=<expiry>&skn=<keyname>`
+ *
+ * @internal
+ */
+class SasTokenProviderImpl {
+    /**
+     * Initializes a new instance of SasTokenProvider
+     * @param credential - The source `NamedKeyCredential` or `SASCredential`.
+     */
+    constructor(credential) {
+        this._credential = credential;
+    }
+    /**
+     * Property used to distinguish TokenProvider from TokenCredential.
+     */
+    get isSasTokenProvider() {
+        return true;
+    }
+    /**
+     * Gets the sas token for the specified audience
+     * @param audience - The audience for which the token is desired.
+     */
+    getToken(audience) {
+        if (coreAuth.isNamedKeyCredential(this._credential)) {
+            return createToken(this._credential.name, this._credential.key, Math.floor(Date.now() / 1000) + 3600, audience);
+        }
+        else {
+            return {
+                token: this._credential.signature,
+                expiresOnTimestamp: 0
+            };
+        }
+    }
+}
+/**
+ * Creates the sas token based on the provided information.
+ * @param keyName - The shared access key name.
+ * @param key - The shared access key.
+ * @param expiry - The time period in unix time after which the token will expire.
+ * @param audience - The audience for which the token is desired.
+ * @internal
+ */
+function createToken(keyName, key, expiry, audience) {
+    audience = encodeURIComponent(audience);
+    keyName = encodeURIComponent(keyName);
+    const stringToSign = audience + "\n" + expiry;
+    const shaObj = new jssha("SHA-256", "TEXT");
+    shaObj.setHMACKey(key, "TEXT");
+    shaObj.update(stringToSign);
+    const sig = encodeURIComponent(shaObj.getHMAC("B64"));
+    return {
+        token: `SharedAccessSignature sr=${audience}&sig=${sig}&se=${expiry}&skn=${keyName}`,
+        expiresOnTimestamp: expiry
+    };
+}
+
 exports.AmqpAnnotatedMessage = AmqpAnnotatedMessage;
 exports.AmqpMessageHeader = AmqpMessageHeader;
 exports.AmqpMessageProperties = AmqpMessageProperties;
@@ -1915,9 +2174,12 @@ exports.ConnectionContextBase = ConnectionContextBase;
 exports.Constants = Constants;
 exports.MessagingError = MessagingError;
 exports.RequestResponseLink = RequestResponseLink;
-exports.defaultLock = defaultLock;
+exports.StandardAbortMessage = StandardAbortMessage;
+exports.createSasTokenProvider = createSasTokenProvider;
+exports.defaultCancellableLock = defaultCancellableLock;
 exports.delay = delay;
 exports.isMessagingError = isMessagingError;
+exports.isSasTokenProvider = isSasTokenProvider;
 exports.isSystemError = isSystemError;
 exports.logger = logger;
 exports.parseConnectionString = parseConnectionString;