in ts/src/client.ts [890:1159]
async doRequest(params: $OpenApiUtil.Params, request: $OpenApiUtil.OpenApiRequest, runtime: $dara.RuntimeOptions): Promise<{[key: string]: any}> {
let _runtime: { [key: string]: any } = {
key: runtime.key || this._key,
cert: runtime.cert || this._cert,
ca: runtime.ca || this._ca,
readTimeout: runtime.readTimeout || this._readTimeout,
connectTimeout: runtime.connectTimeout || this._connectTimeout,
httpProxy: runtime.httpProxy || this._httpProxy,
httpsProxy: runtime.httpsProxy || this._httpsProxy,
noProxy: runtime.noProxy || this._noProxy,
socks5Proxy: runtime.socks5Proxy || this._socks5Proxy,
socks5NetWork: runtime.socks5NetWork || this._socks5NetWork,
maxIdleConns: runtime.maxIdleConns || this._maxIdleConns,
retryOptions: this._retryOptions,
ignoreSSL: runtime.ignoreSSL,
tlsMinVersion: this._tlsMinVersion,
}
let _retriesAttempted = 0;
let _lastRequest = null, _lastResponse = null;
let _context = new $dara.RetryPolicyContext({
retriesAttempted: _retriesAttempted,
});
while ($dara.shouldRetry(_runtime['retryOptions'], _context)) {
if (_retriesAttempted > 0) {
let _backoffTime = $dara.getBackoffDelay(_runtime['retryOptions'], _context);
if (_backoffTime > 0) {
await $dara.sleep(_backoffTime);
}
}
_retriesAttempted = _retriesAttempted + 1;
try {
let request_ = new $dara.Request();
request_.protocol = this._protocol || params.protocol;
request_.method = params.method;
request_.pathname = params.pathname;
let globalQueries : {[key: string ]: string} = { };
let globalHeaders : {[key: string ]: string} = { };
if (!$dara.isNull(this._globalParameters)) {
let globalParams = this._globalParameters;
if (!$dara.isNull(globalParams.queries)) {
globalQueries = globalParams.queries;
}
if (!$dara.isNull(globalParams.headers)) {
globalHeaders = globalParams.headers;
}
}
let extendsHeaders : {[key: string ]: string} = { };
let extendsQueries : {[key: string ]: string} = { };
if (!$dara.isNull(runtime.extendsParameters)) {
let extendsParameters = runtime.extendsParameters;
if (!$dara.isNull(extendsParameters.headers)) {
extendsHeaders = extendsParameters.headers;
}
if (!$dara.isNull(extendsParameters.queries)) {
extendsQueries = extendsParameters.queries;
}
}
request_.query = {
...globalQueries,
...extendsQueries,
...request.query,
};
// endpoint is setted in product client
request_.headers = {
host: this._endpoint,
'x-acs-version': params.version,
'x-acs-action': params.action,
'user-agent': OpenApiUtil.getUserAgent(this._userAgent),
'x-acs-date': OpenApiUtil.getTimestamp(),
'x-acs-signature-nonce': OpenApiUtil.getNonce(),
accept: "application/json",
...globalHeaders,
...extendsHeaders,
...request.headers,
};
if (params.style == "RPC") {
let headers = this.getRpcHeaders();
if (!$dara.isNull(headers)) {
request_.headers = {
...request_.headers,
...headers,
};
}
}
let signatureAlgorithm = this._signatureAlgorithm || "ACS3-HMAC-SHA256";
let hashedRequestPayload = OpenApiUtil.hash(Buffer.from("", "utf-8"), signatureAlgorithm);
if (!$dara.isNull(request.stream)) {
let tmp = await $dara.Stream.readAsBytes(request.stream);
hashedRequestPayload = OpenApiUtil.hash(tmp, signatureAlgorithm);
request_.body = new $dara.BytesReadable(tmp);
request_.headers["content-type"] = "application/octet-stream";
} else {
if (!$dara.isNull(request.body)) {
if (params.reqBodyType == "byte") {
let byteObj = Buffer.from(request.body);
hashedRequestPayload = OpenApiUtil.hash(byteObj, signatureAlgorithm);
request_.body = new $dara.BytesReadable(byteObj);
} else if (params.reqBodyType == "json") {
let jsonObj = typeof request.body === "string" ? request.body : JSON.stringify(request.body);
hashedRequestPayload = OpenApiUtil.hash(Buffer.from(jsonObj, "utf8"), signatureAlgorithm);
request_.body = new $dara.BytesReadable(jsonObj);
request_.headers["content-type"] = "application/json; charset=utf-8";
} else {
let m = request.body;
let formObj = OpenApiUtil.toForm(m);
hashedRequestPayload = OpenApiUtil.hash(Buffer.from(formObj, "utf8"), signatureAlgorithm);
request_.body = new $dara.BytesReadable(formObj);
request_.headers["content-type"] = "application/x-www-form-urlencoded";
}
}
}
request_.headers["x-acs-content-sha256"] = hashedRequestPayload.toString("hex");
if (params.authType != "Anonymous") {
if ($dara.isNull(this._credential)) {
throw new $_error.ClientError({
code: `InvalidCredentials`,
message: `Please set up the credentials correctly. If you are setting them through environment variables, please ensure that ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are set correctly. See https://help.aliyun.com/zh/sdk/developer-reference/configure-the-alibaba-cloud-accesskey-environment-variable-on-linux-macos-and-windows-systems for more details.`,
});
}
let credentialModel = await this._credential.getCredential();
if (!$dara.isNull(credentialModel.providerName)) {
request_.headers["x-acs-credentials-provider"] = credentialModel.providerName;
}
let authType = credentialModel.type;
if (authType == "bearer") {
let bearerToken = credentialModel.bearerToken;
request_.headers["x-acs-bearer-token"] = bearerToken;
if (params.style == "RPC") {
request_.query["SignatureType"] = "BEARERTOKEN";
} else {
request_.headers["x-acs-signature-type"] = "BEARERTOKEN";
}
} else {
let accessKeyId = credentialModel.accessKeyId;
let accessKeySecret = credentialModel.accessKeySecret;
let securityToken = credentialModel.securityToken;
if (!$dara.isNull(securityToken) && securityToken != "") {
request_.headers["x-acs-accesskey-id"] = accessKeyId;
request_.headers["x-acs-security-token"] = securityToken;
}
request_.headers["Authorization"] = OpenApiUtil.getAuthorization(request_, signatureAlgorithm, hashedRequestPayload.toString("hex"), accessKeyId, accessKeySecret);
}
}
let response_ = await $dara.doAction(request_, _runtime);
_lastRequest = request_;
_lastResponse = response_;
if ((response_.statusCode >= 400) && (response_.statusCode < 600)) {
let err : {[key: string ]: any} = { };
if (!$dara.isNull(response_.headers["content-type"]) && response_.headers["content-type"] == "text/xml;charset=utf-8") {
let _str = await $dara.Stream.readAsString(response_.body);
let respMap = $dara.XML.parseXml(_str, null);
err = respMap["Error"];
} else {
let _res = await $dara.Stream.readAsJSON(response_.body);
err = _res;
}
let requestId = err["RequestId"] || err["requestId"];
let code = err["Code"] || err["code"];
if ((`${code}` == "Throttling") || (`${code}` == "Throttling.User") || (`${code}` == "Throttling.Api")) {
throw new $_error.ThrottlingError({
statusCode: response_.statusCode,
code: `${code}`,
message: `code: ${response_.statusCode}, ${err["Message"] || err["message"]} request id: ${requestId}`,
description: `${err["Description"] || err["description"]}`,
retryAfter: OpenApiUtil.getThrottlingTimeLeft(response_.headers),
data: err,
requestId: `${requestId}`,
});
} else if ((response_.statusCode >= 400) && (response_.statusCode < 500)) {
throw new $_error.ClientError({
statusCode: response_.statusCode,
code: `${code}`,
message: `code: ${response_.statusCode}, ${err["Message"] || err["message"]} request id: ${requestId}`,
description: `${err["Description"] || err["description"]}`,
data: err,
accessDeniedDetail: this.getAccessDeniedDetail(err),
requestId: `${requestId}`,
});
} else {
throw new $_error.ServerError({
statusCode: response_.statusCode,
code: `${code}`,
message: `code: ${response_.statusCode}, ${err["Message"] || err["message"]} request id: ${requestId}`,
description: `${err["Description"] || err["description"]}`,
data: err,
requestId: `${requestId}`,
});
}
}
if (params.bodyType == "binary") {
let resp = {
body: response_.body,
headers: response_.headers,
statusCode: response_.statusCode,
};
return resp;
} else if (params.bodyType == "byte") {
let byt = await $dara.Stream.readAsBytes(response_.body);
return {
body: byt,
headers: response_.headers,
statusCode: response_.statusCode,
};
} else if (params.bodyType == "string") {
let respStr = await $dara.Stream.readAsString(response_.body);
return {
body: respStr,
headers: response_.headers,
statusCode: response_.statusCode,
};
} else if (params.bodyType == "json") {
let obj = await $dara.Stream.readAsJSON(response_.body);
let res = obj;
return {
body: res,
headers: response_.headers,
statusCode: response_.statusCode,
};
} else if (params.bodyType == "array") {
let arr = await $dara.Stream.readAsJSON(response_.body);
return {
body: arr,
headers: response_.headers,
statusCode: response_.statusCode,
};
} else {
let anything = await $dara.Stream.readAsString(response_.body);
return {
body: anything,
headers: response_.headers,
statusCode: response_.statusCode,
};
}
} catch (ex) {
_context = new $dara.RetryPolicyContext({
retriesAttempted : _retriesAttempted,
httpRequest : _lastRequest,
httpResponse : _lastResponse,
exception : ex,
});
continue;
}
}
throw $dara.newUnretryableError(_context);
}