@azure/cosmos
Version:
Microsoft Azure Cosmos DB Service Node.js SDK for NOSQL API
176 lines (175 loc) • 8.55 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var retryUtility_exports = {};
__export(retryUtility_exports, {
execute: () => execute
});
module.exports = __toCommonJS(retryUtility_exports);
var import_constants = require("../common/constants.js");
var import_helper = require("../common/helper.js");
var import_statusCodes = require("../common/statusCodes.js");
var import_DiagnosticNodeInternal = require("../diagnostics/DiagnosticNodeInternal.js");
var import_TimeoutError = require("../request/TimeoutError.js");
var import_diagnostics = require("../utils/diagnostics.js");
var import_time = require("../utils/time.js");
var import_defaultRetryPolicy = require("./defaultRetryPolicy.js");
var import_endpointDiscoveryRetryPolicy = require("./endpointDiscoveryRetryPolicy.js");
var import_resourceThrottleRetryPolicy = require("./resourceThrottleRetryPolicy.js");
var import_sessionRetryPolicy = require("./sessionRetryPolicy.js");
var import_timeoutFailoverRetryPolicy = require("./timeoutFailoverRetryPolicy.js");
async function execute({
diagnosticNode,
retryContext = { retryCount: 0 },
retryPolicies,
requestContext,
executeRequest
}) {
return (0, import_diagnostics.addDiagnosticChild)(
async (localDiagnosticNode) => {
localDiagnosticNode.addData({ requestAttempNumber: retryContext.retryCount });
if (!retryPolicies) {
retryPolicies = {
endpointDiscoveryRetryPolicy: new import_endpointDiscoveryRetryPolicy.EndpointDiscoveryRetryPolicy(
requestContext.globalEndpointManager,
requestContext.resourceType,
requestContext.operationType,
requestContext.globalPartitionEndpointManager
),
resourceThrottleRetryPolicy: new import_resourceThrottleRetryPolicy.ResourceThrottleRetryPolicy(
requestContext.connectionPolicy.retryOptions ?? {}
),
sessionReadRetryPolicy: new import_sessionRetryPolicy.SessionRetryPolicy(
requestContext.globalEndpointManager,
requestContext.resourceType,
requestContext.operationType,
requestContext.connectionPolicy
),
defaultRetryPolicy: new import_defaultRetryPolicy.DefaultRetryPolicy(requestContext.operationType),
timeoutFailoverRetryPolicy: new import_timeoutFailoverRetryPolicy.TimeoutFailoverRetryPolicy(
requestContext.globalEndpointManager,
requestContext.headers,
requestContext.method,
requestContext.resourceType,
requestContext.operationType,
requestContext.connectionPolicy.enableEndpointDiscovery,
requestContext.globalPartitionEndpointManager
)
};
}
if (retryContext && retryContext.clearSessionTokenNotAvailable) {
requestContext.client.clearSessionToken(requestContext.path);
delete requestContext.headers["x-ms-session-token"];
}
if (retryContext && retryContext.retryLocationServerIndex) {
requestContext.endpoint = await requestContext.globalEndpointManager.resolveServiceEndpointInternal({
diagnosticNode: localDiagnosticNode,
resourceType: requestContext.resourceType,
operationType: requestContext.operationType,
startServiceEndpointIndex: retryContext.retryLocationServerIndex,
excludedLocations: requestContext.options?.excludedLocations
});
} else {
requestContext.endpoint = await requestContext.globalEndpointManager.resolveServiceEndpointInternal({
diagnosticNode: localDiagnosticNode,
resourceType: requestContext.resourceType,
operationType: requestContext.operationType,
startServiceEndpointIndex: 0,
excludedLocations: requestContext.options?.excludedLocations
});
}
const startTimeUTCInMs = (0, import_time.getCurrentTimestampInMs)();
const correlatedActivityId = requestContext.headers[import_constants.Constants.HttpHeaders.CorrelatedActivityId];
if (requestContext.globalPartitionEndpointManager) {
requestContext = await requestContext.globalPartitionEndpointManager.tryAddPartitionLevelLocationOverride(
requestContext,
localDiagnosticNode
);
}
try {
const response = await executeRequest(localDiagnosticNode, requestContext);
response.headers[import_constants.Constants.ThrottleRetryCount] = retryPolicies.resourceThrottleRetryPolicy.currentRetryAttemptCount;
response.headers[import_constants.Constants.ThrottleRetryWaitTimeInMs] = retryPolicies.resourceThrottleRetryPolicy.cummulativeWaitTimeinMs;
if (correlatedActivityId) {
response.headers[import_constants.Constants.HttpHeaders.CorrelatedActivityId] = correlatedActivityId;
}
return response;
} catch (err) {
let retryPolicy = null;
const headers = err.headers || {};
if (correlatedActivityId) {
headers[import_constants.Constants.HttpHeaders.CorrelatedActivityId] = correlatedActivityId;
}
if (err.code === import_statusCodes.StatusCodes.ENOTFOUND || err.code === "REQUEST_SEND_ERROR" || err.code === import_statusCodes.StatusCodes.Forbidden && (err.substatus === import_statusCodes.SubStatusCodes.DatabaseAccountNotFound || err.substatus === import_statusCodes.SubStatusCodes.WriteForbidden)) {
retryPolicy = retryPolicies.endpointDiscoveryRetryPolicy;
} else if (err.code === import_statusCodes.StatusCodes.TooManyRequests && !isBulkRequest(requestContext)) {
retryPolicy = retryPolicies.resourceThrottleRetryPolicy;
} else if (err.code === import_statusCodes.StatusCodes.NotFound && err.substatus === import_statusCodes.SubStatusCodes.ReadSessionNotAvailable) {
retryPolicy = retryPolicies.sessionReadRetryPolicy;
} else if (err.code === import_statusCodes.StatusCodes.ServiceUnavailable || err.code === import_TimeoutError.TimeoutErrorCode) {
retryPolicy = retryPolicies.timeoutFailoverRetryPolicy;
} else {
retryPolicy = retryPolicies.defaultRetryPolicy;
}
const results = await retryPolicy.shouldRetry(
err,
localDiagnosticNode,
retryContext,
requestContext.endpoint,
requestContext
);
if (!results) {
headers[import_constants.Constants.ThrottleRetryCount] = retryPolicies.resourceThrottleRetryPolicy.currentRetryAttemptCount;
headers[import_constants.Constants.ThrottleRetryWaitTimeInMs] = retryPolicies.resourceThrottleRetryPolicy.cummulativeWaitTimeinMs;
err.headers = { ...err.headers, ...headers };
throw err;
} else {
requestContext.retryCount++;
const newUrl = results[1];
if (newUrl !== void 0) {
requestContext.endpoint = newUrl;
}
localDiagnosticNode.recordFailedNetworkCall(
startTimeUTCInMs,
requestContext,
retryContext.retryCount,
err.code,
err.subsstatusCode,
headers
);
await (0, import_helper.sleep)(retryPolicy.retryAfterInMs);
return execute({
diagnosticNode,
executeRequest,
requestContext,
retryContext,
retryPolicies
});
}
}
},
diagnosticNode,
import_DiagnosticNodeInternal.DiagnosticNodeType.HTTP_REQUEST
);
}
function isBulkRequest(requestContext) {
return requestContext.operationType === "batch" && !requestContext.headers[import_constants.Constants.HttpHeaders.IsBatchAtomic];
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
execute
});