mirror of
https://github.com/musix-org/musix-oss
synced 2024-11-14 03:30:18 +00:00
83 lines
3.8 KiB
JavaScript
83 lines
3.8 KiB
JavaScript
"use strict";
|
|
/**
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* 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 });
|
|
/**
|
|
* Provides function wrappers that implement page streaming and retrying.
|
|
*/
|
|
const apiCaller_1 = require("./apiCaller");
|
|
const retries_1 = require("./normalCalls/retries");
|
|
const timeout_1 = require("./normalCalls/timeout");
|
|
/**
|
|
* Converts an rpc call into an API call governed by the settings.
|
|
*
|
|
* In typical usage, `func` will be a promise to a callable used to make an rpc
|
|
* request. This will mostly likely be a bound method from a request stub used
|
|
* to make an rpc call. It is not a direct function but a Promise instance,
|
|
* because of its asynchronism (typically, obtaining the auth information).
|
|
*
|
|
* The result is a function which manages the API call with the given settings
|
|
* and the options on the invocation.
|
|
*
|
|
* @param {Promise<GRPCCall>|GRPCCall} func - is either a promise to be used to make
|
|
* a bare RPC call, or just a bare RPC call.
|
|
* @param {CallSettings} settings - provides the settings for this call
|
|
* @param {Descriptor} descriptor - optionally specify the descriptor for
|
|
* the method call.
|
|
* @return {GaxCall} func - a bound method on a request stub used
|
|
* to make an rpc call.
|
|
*/
|
|
function createApiCall(func, settings, descriptor) {
|
|
// we want to be able to accept both promise resolving to a function and a
|
|
// function. Currently client librares are only calling this method with a
|
|
// promise, but it will change.
|
|
const funcPromise = typeof func === 'function' ? Promise.resolve(func) : func;
|
|
// the following apiCaller will be used for all calls of this function...
|
|
const apiCaller = apiCaller_1.createAPICaller(settings, descriptor);
|
|
return (request, callOptions, callback) => {
|
|
const thisSettings = settings.merge(callOptions);
|
|
let currentApiCaller = apiCaller;
|
|
// special case: if bundling is disabled for this one call,
|
|
// use default API caller instead
|
|
if (settings.isBundling && !thisSettings.isBundling) {
|
|
currentApiCaller = apiCaller_1.createAPICaller(settings, undefined);
|
|
}
|
|
const ongoingCall = currentApiCaller.init(thisSettings, callback);
|
|
funcPromise
|
|
.then((func) => {
|
|
// Initially, the function is just what gRPC server stub contains.
|
|
func = currentApiCaller.wrap(func);
|
|
const retry = thisSettings.retry;
|
|
if (retry && retry.retryCodes && retry.retryCodes.length > 0) {
|
|
return retries_1.retryable(func, thisSettings.retry, thisSettings.otherArgs);
|
|
}
|
|
return timeout_1.addTimeoutArg(func, thisSettings.timeout, thisSettings.otherArgs);
|
|
})
|
|
.then((apiCall) => {
|
|
// After adding retries / timeouts, the call function becomes simpler:
|
|
// it only accepts request and callback.
|
|
currentApiCaller.call(apiCall, request, thisSettings, ongoingCall);
|
|
})
|
|
.catch(err => {
|
|
currentApiCaller.fail(ongoingCall, err);
|
|
});
|
|
// Calls normally return a "cancellable promise" that can be used to `await` for the actual result,
|
|
// or to cancel the ongoing call.
|
|
return currentApiCaller.result(ongoingCall);
|
|
};
|
|
}
|
|
exports.createApiCall = createApiCall;
|
|
//# sourceMappingURL=createApiCall.js.map
|