in src/openApiService/lib/client.ts [110:299]
async doRequest(params, request, runtime) {
let _runtime = {
timeouted: "retry",
readTimeout: Util.defaultNumber(runtime.readTimeout, this._readTimeout),
connectTimeout: Util.defaultNumber(runtime.connectTimeout, this._connectTimeout),
httpProxy: Util.defaultString(runtime.httpProxy, this._httpProxy),
httpsProxy: Util.defaultString(runtime.httpsProxy, this._httpsProxy),
noProxy: Util.defaultString(runtime.noProxy, this._noProxy),
maxIdleConns: Util.defaultNumber(runtime.maxIdleConns, this._maxIdleConns),
retry: {
retryable: runtime.autoretry,
maxAttempts: Util.defaultNumber(runtime.maxAttempts, 3),
},
backoff: {
policy: Util.defaultString(runtime.backoffPolicy, "no"),
period: Util.defaultNumber(runtime.backoffPeriod, 1),
},
ignoreSSL: runtime.ignoreSSL,
};
let _lastRequest = null;
let _now = Date.now();
let _retryTimes = 0;
while ($tea.allowRetry(_runtime["retry"], _retryTimes, _now)) {
if (_retryTimes > 0) {
let _backoffTime = $tea.getBackoffTime(_runtime["backoff"], _retryTimes);
if (_backoffTime > 0) {
await $tea.sleep(_backoffTime);
}
}
_retryTimes = _retryTimes + 1;
let entry;
try {
let request_ = new $tea.Request();
request_.protocol = Util.defaultString(this._protocol, params.protocol);
request_.method = params.method;
request_.pathname = OpenApiUtil.getEncodePath(params.pathname);
request_.query = OpenApiUtil.query(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": getUserAgent(),
"x-acs-date": OpenApiUtil.getTimestamp(),
"x-acs-signature-nonce": Util.getNonce(),
accept: "application/json",
...request.headers,
};
if (request.headers && request.headers["Host"]) {
delete request_.headers["Host"];
request_.headers["host"] = request.headers["Host"];
}
let signatureAlgorithm = Util.defaultString(this._signatureAlgorithm, "ACS3-HMAC-SHA256");
let hashedRequestPayload = OpenApiUtil.hexEncode(OpenApiUtil.hash(Util.toBytes(""), signatureAlgorithm));
if (!Util.isUnset(request.stream)) {
let tmp = await Util.readAsBytes(request.stream);
hashedRequestPayload = OpenApiUtil.hexEncode(OpenApiUtil.hash(tmp, signatureAlgorithm));
request_.body = new $tea.BytesReadable(tmp);
request_.headers["content-type"] = "application/octet-stream";
} else {
if (!Util.isUnset(request.body)) {
if (Util.equalString(params.reqBodyType, "json")) {
let jsonObj = Util.toJSONString(request.body);
hashedRequestPayload = OpenApiUtil.hexEncode(OpenApiUtil.hash(Util.toBytes(jsonObj), signatureAlgorithm));
request_.body = new $tea.BytesReadable(jsonObj);
request_.headers["content-type"] = "application/json; charset=utf-8";
} else {
let m = Util.assertAsMap(request.body);
let formObj = OpenApiUtil.toForm(m);
hashedRequestPayload = OpenApiUtil.hexEncode(OpenApiUtil.hash(Util.toBytes(formObj), signatureAlgorithm));
request_.body = new $tea.BytesReadable(formObj);
request_.headers["content-type"] = "application/x-www-form-urlencoded";
}
}
}
request_.headers["x-acs-content-sha256"] = hashedRequestPayload;
if (!Util.equalString(params.authType, "Anonymous")) {
let accessKeyId = await this.getAccessKeyId();
let accessKeySecret = await this.getAccessKeySecret();
let securityToken = await this.getSecurityToken();
if (!Util.empty(securityToken)) {
request_.headers["x-acs-accesskey-id"] = accessKeyId;
request_.headers["x-acs-security-token"] = securityToken;
}
request_.headers["Authorization"] = OpenApiUtil.getAuthorization(
request_,
signatureAlgorithm,
hashedRequestPayload,
accessKeyId,
accessKeySecret,
);
}
request_.headers["host"] = this._endpoint;
if (request.headers && request.headers["Host"]) {
request_.headers["Host"] = request.headers["Host"];
}
_lastRequest = request_;
console.log("_lastRequest", _lastRequest);
let response_ = await $tea.doAction(request_, _runtime);
entry = {
request: {
headers: request_.headers,
},
response: {
statusCode: response_.statusCode,
headers: response_.headers,
},
};
if (Util.is4xx(response_.statusCode) || Util.is5xx(response_.statusCode)) {
let _res = await Util.readAsJSON(response_.body);
let err = Util.assertAsMap(_res);
return {
format: "json",
result: err,
entry,
};
}
if (
response_.statusCode === 204 &&
(Util.isUnset(response_.headers["content-type"]) || Util.isUnset(response_.headers["content-length"]))
) {
let str = await Util.readAsString(response_.body);
return {
format: "string",
result: str,
entry,
};
}
if (Util.equalString(params.bodyType, "binary")) {
return {
format: "binary",
result: response_.body,
entry,
};
} else if (Util.equalString(params.bodyType, "byte")) {
let byt = await Util.readAsBytes(response_.body);
return {
format: "byte",
result: byt,
entry,
};
} else if (Util.equalString(params.bodyType, "string")) {
let str = await Util.readAsString(response_.body);
return {
format: "string",
result: str,
entry,
};
} else if (Util.equalString(params.bodyType, "json")) {
let obj = await Util.readAsJSON(response_.body);
let res = Util.assertAsMap(obj);
return {
format: "json",
result: res,
entry,
};
} else if (Util.equalString(params.bodyType, "array")) {
let arr = await Util.readAsJSON(response_.body);
return {
format: "json",
result: arr,
entry,
};
}
let str = await Util.readAsString(response_.body);
return {
format: "string",
result: str,
entry,
};
} catch (ex) {
if ($tea.isRetryable(ex)) {
continue;
}
ex.entry = entry;
throw ex;
}
}
throw $tea.newUnretryableError(_lastRequest);
}