summaryrefslogtreecommitdiff
path: root/frontend-old/node_modules/@grpc/grpc-js/build/src/retrying-call.js
diff options
context:
space:
mode:
authoraltaf-creator <dev@altafcreator.com>2025-11-09 11:15:19 +0800
committeraltaf-creator <dev@altafcreator.com>2025-11-09 11:15:19 +0800
commit8eff962cab608341a6f2fedc640a0e32d96f26e2 (patch)
tree05534d1a720ddc3691d346c69b4972555820a061 /frontend-old/node_modules/@grpc/grpc-js/build/src/retrying-call.js
pain
Diffstat (limited to 'frontend-old/node_modules/@grpc/grpc-js/build/src/retrying-call.js')
-rw-r--r--frontend-old/node_modules/@grpc/grpc-js/build/src/retrying-call.js639
1 files changed, 639 insertions, 0 deletions
diff --git a/frontend-old/node_modules/@grpc/grpc-js/build/src/retrying-call.js b/frontend-old/node_modules/@grpc/grpc-js/build/src/retrying-call.js
new file mode 100644
index 0000000..6db6ce9
--- /dev/null
+++ b/frontend-old/node_modules/@grpc/grpc-js/build/src/retrying-call.js
@@ -0,0 +1,639 @@
+"use strict";
+/*
+ * Copyright 2022 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryingCall = exports.MessageBufferTracker = exports.RetryThrottler = void 0;
+const constants_1 = require("./constants");
+const metadata_1 = require("./metadata");
+const logging = require("./logging");
+const TRACER_NAME = 'retrying_call';
+class RetryThrottler {
+ constructor(maxTokens, tokenRatio, previousRetryThrottler) {
+ this.maxTokens = maxTokens;
+ this.tokenRatio = tokenRatio;
+ if (previousRetryThrottler) {
+ /* When carrying over tokens from a previous config, rescale them to the
+ * new max value */
+ this.tokens =
+ previousRetryThrottler.tokens *
+ (maxTokens / previousRetryThrottler.maxTokens);
+ }
+ else {
+ this.tokens = maxTokens;
+ }
+ }
+ addCallSucceeded() {
+ this.tokens = Math.max(this.tokens + this.tokenRatio, this.maxTokens);
+ }
+ addCallFailed() {
+ this.tokens = Math.min(this.tokens - 1, 0);
+ }
+ canRetryCall() {
+ return this.tokens > this.maxTokens / 2;
+ }
+}
+exports.RetryThrottler = RetryThrottler;
+class MessageBufferTracker {
+ constructor(totalLimit, limitPerCall) {
+ this.totalLimit = totalLimit;
+ this.limitPerCall = limitPerCall;
+ this.totalAllocated = 0;
+ this.allocatedPerCall = new Map();
+ }
+ allocate(size, callId) {
+ var _a;
+ const currentPerCall = (_a = this.allocatedPerCall.get(callId)) !== null && _a !== void 0 ? _a : 0;
+ if (this.limitPerCall - currentPerCall < size ||
+ this.totalLimit - this.totalAllocated < size) {
+ return false;
+ }
+ this.allocatedPerCall.set(callId, currentPerCall + size);
+ this.totalAllocated += size;
+ return true;
+ }
+ free(size, callId) {
+ var _a;
+ if (this.totalAllocated < size) {
+ throw new Error(`Invalid buffer allocation state: call ${callId} freed ${size} > total allocated ${this.totalAllocated}`);
+ }
+ this.totalAllocated -= size;
+ const currentPerCall = (_a = this.allocatedPerCall.get(callId)) !== null && _a !== void 0 ? _a : 0;
+ if (currentPerCall < size) {
+ throw new Error(`Invalid buffer allocation state: call ${callId} freed ${size} > allocated for call ${currentPerCall}`);
+ }
+ this.allocatedPerCall.set(callId, currentPerCall - size);
+ }
+ freeAll(callId) {
+ var _a;
+ const currentPerCall = (_a = this.allocatedPerCall.get(callId)) !== null && _a !== void 0 ? _a : 0;
+ if (this.totalAllocated < currentPerCall) {
+ throw new Error(`Invalid buffer allocation state: call ${callId} allocated ${currentPerCall} > total allocated ${this.totalAllocated}`);
+ }
+ this.totalAllocated -= currentPerCall;
+ this.allocatedPerCall.delete(callId);
+ }
+}
+exports.MessageBufferTracker = MessageBufferTracker;
+const PREVIONS_RPC_ATTEMPTS_METADATA_KEY = 'grpc-previous-rpc-attempts';
+class RetryingCall {
+ constructor(channel, callConfig, methodName, host, credentials, deadline, callNumber, bufferTracker, retryThrottler) {
+ this.channel = channel;
+ this.callConfig = callConfig;
+ this.methodName = methodName;
+ this.host = host;
+ this.credentials = credentials;
+ this.deadline = deadline;
+ this.callNumber = callNumber;
+ this.bufferTracker = bufferTracker;
+ this.retryThrottler = retryThrottler;
+ this.listener = null;
+ this.initialMetadata = null;
+ this.underlyingCalls = [];
+ this.writeBuffer = [];
+ /**
+ * The offset of message indices in the writeBuffer. For example, if
+ * writeBufferOffset is 10, message 10 is in writeBuffer[0] and message 15
+ * is in writeBuffer[5].
+ */
+ this.writeBufferOffset = 0;
+ /**
+ * Tracks whether a read has been started, so that we know whether to start
+ * reads on new child calls. This only matters for the first read, because
+ * once a message comes in the child call becomes committed and there will
+ * be no new child calls.
+ */
+ this.readStarted = false;
+ this.transparentRetryUsed = false;
+ /**
+ * Number of attempts so far
+ */
+ this.attempts = 0;
+ this.hedgingTimer = null;
+ this.committedCallIndex = null;
+ this.initialRetryBackoffSec = 0;
+ this.nextRetryBackoffSec = 0;
+ if (callConfig.methodConfig.retryPolicy) {
+ this.state = 'RETRY';
+ const retryPolicy = callConfig.methodConfig.retryPolicy;
+ this.nextRetryBackoffSec = this.initialRetryBackoffSec = Number(retryPolicy.initialBackoff.substring(0, retryPolicy.initialBackoff.length - 1));
+ }
+ else if (callConfig.methodConfig.hedgingPolicy) {
+ this.state = 'HEDGING';
+ }
+ else {
+ this.state = 'TRANSPARENT_ONLY';
+ }
+ }
+ getCallNumber() {
+ return this.callNumber;
+ }
+ trace(text) {
+ logging.trace(constants_1.LogVerbosity.DEBUG, TRACER_NAME, '[' + this.callNumber + '] ' + text);
+ }
+ reportStatus(statusObject) {
+ this.trace('ended with status: code=' +
+ statusObject.code +
+ ' details="' +
+ statusObject.details +
+ '"');
+ this.bufferTracker.freeAll(this.callNumber);
+ this.writeBufferOffset = this.writeBufferOffset + this.writeBuffer.length;
+ this.writeBuffer = [];
+ process.nextTick(() => {
+ var _a;
+ // Explicitly construct status object to remove progress field
+ (_a = this.listener) === null || _a === void 0 ? void 0 : _a.onReceiveStatus({
+ code: statusObject.code,
+ details: statusObject.details,
+ metadata: statusObject.metadata,
+ });
+ });
+ }
+ cancelWithStatus(status, details) {
+ this.trace('cancelWithStatus code: ' + status + ' details: "' + details + '"');
+ this.reportStatus({ code: status, details, metadata: new metadata_1.Metadata() });
+ for (const { call } of this.underlyingCalls) {
+ call.cancelWithStatus(status, details);
+ }
+ }
+ getPeer() {
+ if (this.committedCallIndex !== null) {
+ return this.underlyingCalls[this.committedCallIndex].call.getPeer();
+ }
+ else {
+ return 'unknown';
+ }
+ }
+ getBufferEntry(messageIndex) {
+ var _a;
+ return ((_a = this.writeBuffer[messageIndex - this.writeBufferOffset]) !== null && _a !== void 0 ? _a : {
+ entryType: 'FREED',
+ allocated: false,
+ });
+ }
+ getNextBufferIndex() {
+ return this.writeBufferOffset + this.writeBuffer.length;
+ }
+ clearSentMessages() {
+ if (this.state !== 'COMMITTED') {
+ return;
+ }
+ const earliestNeededMessageIndex = this.underlyingCalls[this.committedCallIndex].nextMessageToSend;
+ for (let messageIndex = this.writeBufferOffset; messageIndex < earliestNeededMessageIndex; messageIndex++) {
+ const bufferEntry = this.getBufferEntry(messageIndex);
+ if (bufferEntry.allocated) {
+ this.bufferTracker.free(bufferEntry.message.message.length, this.callNumber);
+ }
+ }
+ this.writeBuffer = this.writeBuffer.slice(earliestNeededMessageIndex - this.writeBufferOffset);
+ this.writeBufferOffset = earliestNeededMessageIndex;
+ }
+ commitCall(index) {
+ if (this.state === 'COMMITTED') {
+ return;
+ }
+ if (this.underlyingCalls[index].state === 'COMPLETED') {
+ return;
+ }
+ this.trace('Committing call [' +
+ this.underlyingCalls[index].call.getCallNumber() +
+ '] at index ' +
+ index);
+ this.state = 'COMMITTED';
+ this.committedCallIndex = index;
+ for (let i = 0; i < this.underlyingCalls.length; i++) {
+ if (i === index) {
+ continue;
+ }
+ if (this.underlyingCalls[i].state === 'COMPLETED') {
+ continue;
+ }
+ this.underlyingCalls[i].state = 'COMPLETED';
+ this.underlyingCalls[i].call.cancelWithStatus(constants_1.Status.CANCELLED, 'Discarded in favor of other hedged attempt');
+ }
+ this.clearSentMessages();
+ }
+ commitCallWithMostMessages() {
+ if (this.state === 'COMMITTED') {
+ return;
+ }
+ let mostMessages = -1;
+ let callWithMostMessages = -1;
+ for (const [index, childCall] of this.underlyingCalls.entries()) {
+ if (childCall.state === 'ACTIVE' &&
+ childCall.nextMessageToSend > mostMessages) {
+ mostMessages = childCall.nextMessageToSend;
+ callWithMostMessages = index;
+ }
+ }
+ if (callWithMostMessages === -1) {
+ /* There are no active calls, disable retries to force the next call that
+ * is started to be committed. */
+ this.state = 'TRANSPARENT_ONLY';
+ }
+ else {
+ this.commitCall(callWithMostMessages);
+ }
+ }
+ isStatusCodeInList(list, code) {
+ return list.some(value => value === code ||
+ value.toString().toLowerCase() === constants_1.Status[code].toLowerCase());
+ }
+ getNextRetryBackoffMs() {
+ var _a;
+ const retryPolicy = (_a = this.callConfig) === null || _a === void 0 ? void 0 : _a.methodConfig.retryPolicy;
+ if (!retryPolicy) {
+ return 0;
+ }
+ const nextBackoffMs = Math.random() * this.nextRetryBackoffSec * 1000;
+ const maxBackoffSec = Number(retryPolicy.maxBackoff.substring(0, retryPolicy.maxBackoff.length - 1));
+ this.nextRetryBackoffSec = Math.min(this.nextRetryBackoffSec * retryPolicy.backoffMultiplier, maxBackoffSec);
+ return nextBackoffMs;
+ }
+ maybeRetryCall(pushback, callback) {
+ if (this.state !== 'RETRY') {
+ callback(false);
+ return;
+ }
+ const retryPolicy = this.callConfig.methodConfig.retryPolicy;
+ if (this.attempts >= Math.min(retryPolicy.maxAttempts, 5)) {
+ callback(false);
+ return;
+ }
+ let retryDelayMs;
+ if (pushback === null) {
+ retryDelayMs = this.getNextRetryBackoffMs();
+ }
+ else if (pushback < 0) {
+ this.state = 'TRANSPARENT_ONLY';
+ callback(false);
+ return;
+ }
+ else {
+ retryDelayMs = pushback;
+ this.nextRetryBackoffSec = this.initialRetryBackoffSec;
+ }
+ setTimeout(() => {
+ var _a, _b;
+ if (this.state !== 'RETRY') {
+ callback(false);
+ return;
+ }
+ if ((_b = (_a = this.retryThrottler) === null || _a === void 0 ? void 0 : _a.canRetryCall()) !== null && _b !== void 0 ? _b : true) {
+ callback(true);
+ this.attempts += 1;
+ this.startNewAttempt();
+ }
+ }, retryDelayMs);
+ }
+ countActiveCalls() {
+ let count = 0;
+ for (const call of this.underlyingCalls) {
+ if ((call === null || call === void 0 ? void 0 : call.state) === 'ACTIVE') {
+ count += 1;
+ }
+ }
+ return count;
+ }
+ handleProcessedStatus(status, callIndex, pushback) {
+ var _a, _b, _c;
+ switch (this.state) {
+ case 'COMMITTED':
+ case 'TRANSPARENT_ONLY':
+ this.commitCall(callIndex);
+ this.reportStatus(status);
+ break;
+ case 'HEDGING':
+ if (this.isStatusCodeInList((_a = this.callConfig.methodConfig.hedgingPolicy.nonFatalStatusCodes) !== null && _a !== void 0 ? _a : [], status.code)) {
+ (_b = this.retryThrottler) === null || _b === void 0 ? void 0 : _b.addCallFailed();
+ let delayMs;
+ if (pushback === null) {
+ delayMs = 0;
+ }
+ else if (pushback < 0) {
+ this.state = 'TRANSPARENT_ONLY';
+ this.commitCall(callIndex);
+ this.reportStatus(status);
+ return;
+ }
+ else {
+ delayMs = pushback;
+ }
+ setTimeout(() => {
+ this.maybeStartHedgingAttempt();
+ // If after trying to start a call there are no active calls, this was the last one
+ if (this.countActiveCalls() === 0) {
+ this.commitCall(callIndex);
+ this.reportStatus(status);
+ }
+ }, delayMs);
+ }
+ else {
+ this.commitCall(callIndex);
+ this.reportStatus(status);
+ }
+ break;
+ case 'RETRY':
+ if (this.isStatusCodeInList(this.callConfig.methodConfig.retryPolicy.retryableStatusCodes, status.code)) {
+ (_c = this.retryThrottler) === null || _c === void 0 ? void 0 : _c.addCallFailed();
+ this.maybeRetryCall(pushback, retried => {
+ if (!retried) {
+ this.commitCall(callIndex);
+ this.reportStatus(status);
+ }
+ });
+ }
+ else {
+ this.commitCall(callIndex);
+ this.reportStatus(status);
+ }
+ break;
+ }
+ }
+ getPushback(metadata) {
+ const mdValue = metadata.get('grpc-retry-pushback-ms');
+ if (mdValue.length === 0) {
+ return null;
+ }
+ try {
+ return parseInt(mdValue[0]);
+ }
+ catch (e) {
+ return -1;
+ }
+ }
+ handleChildStatus(status, callIndex) {
+ var _a;
+ if (this.underlyingCalls[callIndex].state === 'COMPLETED') {
+ return;
+ }
+ this.trace('state=' +
+ this.state +
+ ' handling status with progress ' +
+ status.progress +
+ ' from child [' +
+ this.underlyingCalls[callIndex].call.getCallNumber() +
+ '] in state ' +
+ this.underlyingCalls[callIndex].state);
+ this.underlyingCalls[callIndex].state = 'COMPLETED';
+ if (status.code === constants_1.Status.OK) {
+ (_a = this.retryThrottler) === null || _a === void 0 ? void 0 : _a.addCallSucceeded();
+ this.commitCall(callIndex);
+ this.reportStatus(status);
+ return;
+ }
+ if (this.state === 'COMMITTED') {
+ this.reportStatus(status);
+ return;
+ }
+ const pushback = this.getPushback(status.metadata);
+ switch (status.progress) {
+ case 'NOT_STARTED':
+ // RPC never leaves the client, always safe to retry
+ this.startNewAttempt();
+ break;
+ case 'REFUSED':
+ // RPC reaches the server library, but not the server application logic
+ if (this.transparentRetryUsed) {
+ this.handleProcessedStatus(status, callIndex, pushback);
+ }
+ else {
+ this.transparentRetryUsed = true;
+ this.startNewAttempt();
+ }
+ break;
+ case 'DROP':
+ this.commitCall(callIndex);
+ this.reportStatus(status);
+ break;
+ case 'PROCESSED':
+ this.handleProcessedStatus(status, callIndex, pushback);
+ break;
+ }
+ }
+ maybeStartHedgingAttempt() {
+ if (this.state !== 'HEDGING') {
+ return;
+ }
+ if (!this.callConfig.methodConfig.hedgingPolicy) {
+ return;
+ }
+ const hedgingPolicy = this.callConfig.methodConfig.hedgingPolicy;
+ if (this.attempts >= Math.min(hedgingPolicy.maxAttempts, 5)) {
+ return;
+ }
+ this.attempts += 1;
+ this.startNewAttempt();
+ this.maybeStartHedgingTimer();
+ }
+ maybeStartHedgingTimer() {
+ var _a, _b, _c;
+ if (this.hedgingTimer) {
+ clearTimeout(this.hedgingTimer);
+ }
+ if (this.state !== 'HEDGING') {
+ return;
+ }
+ if (!this.callConfig.methodConfig.hedgingPolicy) {
+ return;
+ }
+ const hedgingPolicy = this.callConfig.methodConfig.hedgingPolicy;
+ if (this.attempts >= Math.min(hedgingPolicy.maxAttempts, 5)) {
+ return;
+ }
+ const hedgingDelayString = (_a = hedgingPolicy.hedgingDelay) !== null && _a !== void 0 ? _a : '0s';
+ const hedgingDelaySec = Number(hedgingDelayString.substring(0, hedgingDelayString.length - 1));
+ this.hedgingTimer = setTimeout(() => {
+ this.maybeStartHedgingAttempt();
+ }, hedgingDelaySec * 1000);
+ (_c = (_b = this.hedgingTimer).unref) === null || _c === void 0 ? void 0 : _c.call(_b);
+ }
+ startNewAttempt() {
+ const child = this.channel.createLoadBalancingCall(this.callConfig, this.methodName, this.host, this.credentials, this.deadline);
+ this.trace('Created child call [' +
+ child.getCallNumber() +
+ '] for attempt ' +
+ this.attempts);
+ const index = this.underlyingCalls.length;
+ this.underlyingCalls.push({
+ state: 'ACTIVE',
+ call: child,
+ nextMessageToSend: 0,
+ });
+ const previousAttempts = this.attempts - 1;
+ const initialMetadata = this.initialMetadata.clone();
+ if (previousAttempts > 0) {
+ initialMetadata.set(PREVIONS_RPC_ATTEMPTS_METADATA_KEY, `${previousAttempts}`);
+ }
+ let receivedMetadata = false;
+ child.start(initialMetadata, {
+ onReceiveMetadata: metadata => {
+ this.trace('Received metadata from child [' + child.getCallNumber() + ']');
+ this.commitCall(index);
+ receivedMetadata = true;
+ if (previousAttempts > 0) {
+ metadata.set(PREVIONS_RPC_ATTEMPTS_METADATA_KEY, `${previousAttempts}`);
+ }
+ if (this.underlyingCalls[index].state === 'ACTIVE') {
+ this.listener.onReceiveMetadata(metadata);
+ }
+ },
+ onReceiveMessage: message => {
+ this.trace('Received message from child [' + child.getCallNumber() + ']');
+ this.commitCall(index);
+ if (this.underlyingCalls[index].state === 'ACTIVE') {
+ this.listener.onReceiveMessage(message);
+ }
+ },
+ onReceiveStatus: status => {
+ this.trace('Received status from child [' + child.getCallNumber() + ']');
+ if (!receivedMetadata && previousAttempts > 0) {
+ status.metadata.set(PREVIONS_RPC_ATTEMPTS_METADATA_KEY, `${previousAttempts}`);
+ }
+ this.handleChildStatus(status, index);
+ },
+ });
+ this.sendNextChildMessage(index);
+ if (this.readStarted) {
+ child.startRead();
+ }
+ }
+ start(metadata, listener) {
+ this.trace('start called');
+ this.listener = listener;
+ this.initialMetadata = metadata;
+ this.attempts += 1;
+ this.startNewAttempt();
+ this.maybeStartHedgingTimer();
+ }
+ handleChildWriteCompleted(childIndex) {
+ var _a, _b;
+ const childCall = this.underlyingCalls[childIndex];
+ const messageIndex = childCall.nextMessageToSend;
+ (_b = (_a = this.getBufferEntry(messageIndex)).callback) === null || _b === void 0 ? void 0 : _b.call(_a);
+ this.clearSentMessages();
+ childCall.nextMessageToSend += 1;
+ this.sendNextChildMessage(childIndex);
+ }
+ sendNextChildMessage(childIndex) {
+ const childCall = this.underlyingCalls[childIndex];
+ if (childCall.state === 'COMPLETED') {
+ return;
+ }
+ if (this.getBufferEntry(childCall.nextMessageToSend)) {
+ const bufferEntry = this.getBufferEntry(childCall.nextMessageToSend);
+ switch (bufferEntry.entryType) {
+ case 'MESSAGE':
+ childCall.call.sendMessageWithContext({
+ callback: error => {
+ // Ignore error
+ this.handleChildWriteCompleted(childIndex);
+ },
+ }, bufferEntry.message.message);
+ break;
+ case 'HALF_CLOSE':
+ childCall.nextMessageToSend += 1;
+ childCall.call.halfClose();
+ break;
+ case 'FREED':
+ // Should not be possible
+ break;
+ }
+ }
+ }
+ sendMessageWithContext(context, message) {
+ var _a;
+ this.trace('write() called with message of length ' + message.length);
+ const writeObj = {
+ message,
+ flags: context.flags,
+ };
+ const messageIndex = this.getNextBufferIndex();
+ const bufferEntry = {
+ entryType: 'MESSAGE',
+ message: writeObj,
+ allocated: this.bufferTracker.allocate(message.length, this.callNumber),
+ };
+ this.writeBuffer.push(bufferEntry);
+ if (bufferEntry.allocated) {
+ (_a = context.callback) === null || _a === void 0 ? void 0 : _a.call(context);
+ for (const [callIndex, call] of this.underlyingCalls.entries()) {
+ if (call.state === 'ACTIVE' &&
+ call.nextMessageToSend === messageIndex) {
+ call.call.sendMessageWithContext({
+ callback: error => {
+ // Ignore error
+ this.handleChildWriteCompleted(callIndex);
+ },
+ }, message);
+ }
+ }
+ }
+ else {
+ this.commitCallWithMostMessages();
+ // commitCallWithMostMessages can fail if we are between ping attempts
+ if (this.committedCallIndex === null) {
+ return;
+ }
+ const call = this.underlyingCalls[this.committedCallIndex];
+ bufferEntry.callback = context.callback;
+ if (call.state === 'ACTIVE' && call.nextMessageToSend === messageIndex) {
+ call.call.sendMessageWithContext({
+ callback: error => {
+ // Ignore error
+ this.handleChildWriteCompleted(this.committedCallIndex);
+ },
+ }, message);
+ }
+ }
+ }
+ startRead() {
+ this.trace('startRead called');
+ this.readStarted = true;
+ for (const underlyingCall of this.underlyingCalls) {
+ if ((underlyingCall === null || underlyingCall === void 0 ? void 0 : underlyingCall.state) === 'ACTIVE') {
+ underlyingCall.call.startRead();
+ }
+ }
+ }
+ halfClose() {
+ this.trace('halfClose called');
+ const halfCloseIndex = this.getNextBufferIndex();
+ this.writeBuffer.push({
+ entryType: 'HALF_CLOSE',
+ allocated: false,
+ });
+ for (const call of this.underlyingCalls) {
+ if ((call === null || call === void 0 ? void 0 : call.state) === 'ACTIVE' &&
+ call.nextMessageToSend === halfCloseIndex) {
+ call.nextMessageToSend += 1;
+ call.call.halfClose();
+ }
+ }
+ }
+ setCredentials(newCredentials) {
+ throw new Error('Method not implemented.');
+ }
+ getMethod() {
+ return this.methodName;
+ }
+ getHost() {
+ return this.host;
+ }
+}
+exports.RetryingCall = RetryingCall;
+//# sourceMappingURL=retrying-call.js.map \ No newline at end of file