in common/go/client/client.go [432:706]
func (client *Client) DoRequest(params *Params, request *OpenApiRequest, runtime *util.RuntimeOptions) (_result map[string]interface{}, _err error) {
_err = tea.Validate(params)
if _err != nil {
return _result, _err
}
_err = tea.Validate(request)
if _err != nil {
return _result, _err
}
_err = tea.Validate(runtime)
if _err != nil {
return _result, _err
}
_runtime := map[string]interface{}{
"timeouted": "retry",
"readTimeout": tea.IntValue(util.DefaultNumber(runtime.ReadTimeout, client.ReadTimeout)),
"connectTimeout": tea.IntValue(util.DefaultNumber(runtime.ConnectTimeout, client.ConnectTimeout)),
"retry": map[string]interface{}{
"retryable": tea.BoolValue(runtime.Autoretry),
"maxAttempts": tea.IntValue(util.DefaultNumber(runtime.MaxAttempts, tea.Int(3))),
},
"backoff": map[string]interface{}{
"policy": tea.StringValue(util.DefaultString(runtime.BackoffPolicy, tea.String("no"))),
"period": tea.IntValue(util.DefaultNumber(runtime.BackoffPeriod, tea.Int(1))),
},
"ignoreSSL": tea.BoolValue(runtime.IgnoreSSL),
}
_resp := make(map[string]interface{})
for _retryTimes := 0; tea.BoolValue(tea.AllowRetry(_runtime["retry"], tea.Int(_retryTimes))); _retryTimes++ {
if _retryTimes > 0 {
_backoffTime := tea.GetBackoffTime(_runtime["backoff"], tea.Int(_retryTimes))
if tea.IntValue(_backoffTime) > 0 {
tea.Sleep(_backoffTime)
}
}
_resp, _err = func()(map[string]interface{}, error){
request_ := tea.NewRequest()
request_.Protocol = util.DefaultString(client.Protocol, params.Protocol)
request_.Method = params.Method
if !tea.BoolValue(util.IsUnset(client.Suffix)) {
request_.Pathname = tea.String("/" + tea.StringValue(client.Suffix) + tea.StringValue(params.Pathname))
} else {
request_.Pathname = params.Pathname
}
globalQueries := make(map[string]*string)
globalHeaders := make(map[string]*string)
if !tea.BoolValue(util.IsUnset(client.GlobalParameters)) {
globalParams := client.GlobalParameters
if !tea.BoolValue(util.IsUnset(globalParams.Queries)) {
globalQueries = globalParams.Queries
}
if !tea.BoolValue(util.IsUnset(globalParams.Headers)) {
globalHeaders = globalParams.Headers
}
}
extendsHeaders := make(map[string]*string)
extendsQueries := make(map[string]*string)
if !tea.BoolValue(util.IsUnset(runtime.ExtendsParameters)) {
extendsParameters := runtime.ExtendsParameters
if !tea.BoolValue(util.IsUnset(extendsParameters.Headers)) {
extendsHeaders = extendsParameters.Headers
}
if !tea.BoolValue(util.IsUnset(extendsParameters.Queries)) {
extendsQueries = extendsParameters.Queries
}
}
request_.Query = tea.Merge(globalQueries,
extendsQueries,
request.Query)
// endpoint is setted in product client
request_.Headers = tea.Merge(map[string]*string{
"host": client.Endpoint,
"user-agent": client.GetUserAgent(),
"x-odps-user-agent": client.GetUserAgent(),
"Date": mcutil.GetApiTimestamp(),
},globalHeaders,
extendsHeaders,
request.Headers)
if !tea.BoolValue(util.IsUnset(request.Stream)) {
tmp, _err := util.ReadAsBytes(request.Stream)
if _err != nil {
return _result, _err
}
request_.Body = tea.ToReader(tmp)
}
if !tea.BoolValue(util.IsUnset(request.Body)) {
jsonObj := util.ToJSONString(request.Body)
request_.Body = tea.ToReader(jsonObj)
request_.Headers["content-type"] = tea.String("application/json; charset=utf-8")
}
canonicalString := mcutil.BuildCanonicalString(params.Method, params.Pathname, request_.Query, request_.Headers)
if !tea.BoolValue(util.EqualString(params.AuthType, tea.String("Anonymous"))) {
if tea.BoolValue(util.IsUnset(client.Credential)) {
_err = tea.NewSDKError(map[string]interface{}{
"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.",
})
return _result, _err
}
credentialModel, _err := client.Credential.GetCredential()
if _err != nil {
return _result, _err
}
authType := credentialModel.Type
if tea.BoolValue(util.EqualString(authType, tea.String("bearer"))) {
bearerToken := credentialModel.BearerToken
request_.Headers["x-odps-bearer-token"] = bearerToken
} else {
accessKeyId := credentialModel.AccessKeyId
accessKeySecret := credentialModel.AccessKeySecret
securityToken := credentialModel.SecurityToken
request_.Headers["Authorization"] = mcutil.GetSignature(canonicalString, accessKeyId, accessKeySecret)
if !tea.BoolValue(util.Empty(securityToken)) {
request_.Headers["authorization-sts-token"] = securityToken
}
}
}
response_, _err := tea.DoRequest(request_, _runtime)
if _err != nil {
return _result, _err
}
if tea.BoolValue(util.EqualNumber(response_.StatusCode, tea.Int(204))) {
_result = make(map[string]interface{})
_err = tea.Convert(map[string]map[string]*string{
"headers": response_.Headers,
}, &_result)
return _result, _err
}
if tea.BoolValue(util.Is4xx(response_.StatusCode)) || tea.BoolValue(util.Is5xx(response_.StatusCode)) {
err := map[string]interface{}{}
responseBody, _err := util.ReadAsString(response_.Body)
if _err != nil {
return _result, _err
}
_, tryErr := func()(_r map[string]interface{}, _e error) {
defer func() {
if r := tea.Recover(recover()); r != nil {
_e = r
}
}()
_res := util.ParseJSON(responseBody)
err, _err = util.AssertAsMap(_res)
if _err != nil {
return _result, _err
}
return nil, nil
}()
if tryErr != nil {
var error = &tea.SDKError{}
if _t, ok := tryErr.(*tea.SDKError); ok {
error = _t
} else {
error.Message = tea.String(tryErr.Error())
}
err = map[string]interface{}{}
err["Code"] = tea.String("Unknown")
err["Message"] = responseBody
}
requestId := mcutil.ToString(DefaultAny(response_.Headers["x-odps-request-id"], response_.Headers["X-Odps-Request-Id"]))
err["statusCode"] = response_.StatusCode
_err = tea.NewSDKError(map[string]interface{}{
"code": tea.ToString(DefaultAny(err["Code"], err["code"])),
"message": "code: " + tea.ToString(tea.IntValue(response_.StatusCode)) + ", " + tea.ToString(DefaultAny(err["Message"], err["message"])) + " request id: " + tea.StringValue(requestId),
"data": err,
"description": tea.ToString(DefaultAny(err["Description"], err["description"])),
"accessDeniedDetail": DefaultAny(err["AccessDeniedDetail"], err["accessDeniedDetail"]),
})
return _result, _err
}
if tea.BoolValue(util.EqualString(params.BodyType, tea.String("binary"))) {
resp := map[string]interface{}{
"body": response_.Body,
"headers": response_.Headers,
"statusCode": tea.IntValue(response_.StatusCode),
}
_result = resp
return _result , _err
} else if tea.BoolValue(util.EqualString(params.BodyType, tea.String("byte"))) {
byt, _err := util.ReadAsBytes(response_.Body)
if _err != nil {
return _result, _err
}
_result = make(map[string]interface{})
_err = tea.Convert(map[string]interface{}{
"body": byt,
"headers": response_.Headers,
"statusCode": tea.IntValue(response_.StatusCode),
}, &_result)
return _result, _err
} else if tea.BoolValue(util.EqualString(params.BodyType, tea.String("string"))) {
str, _err := util.ReadAsString(response_.Body)
if _err != nil {
return _result, _err
}
_result = make(map[string]interface{})
_err = tea.Convert(map[string]interface{}{
"body": tea.StringValue(str),
"headers": response_.Headers,
"statusCode": tea.IntValue(response_.StatusCode),
}, &_result)
return _result, _err
} else if tea.BoolValue(util.EqualString(params.BodyType, tea.String("json"))) {
obj, _err := util.ReadAsJSON(response_.Body)
if _err != nil {
return _result, _err
}
res, _err := util.AssertAsMap(obj)
if _err != nil {
return _result, _err
}
_result = res
return _result , _err
} else if tea.BoolValue(util.EqualString(params.BodyType, tea.String("array"))) {
arr, _err := util.ReadAsJSON(response_.Body)
if _err != nil {
return _result, _err
}
_result = make(map[string]interface{})
_err = tea.Convert(map[string]interface{}{
"body": arr,
"headers": response_.Headers,
"statusCode": tea.IntValue(response_.StatusCode),
}, &_result)
return _result, _err
} else {
anything, _err := util.ReadAsString(response_.Body)
if _err != nil {
return _result, _err
}
_result = make(map[string]interface{})
_err = tea.Convert(map[string]interface{}{
"body": tea.StringValue(anything),
"headers": response_.Headers,
"statusCode": tea.IntValue(response_.StatusCode),
}, &_result)
return _result, _err
}
}()
if !tea.BoolValue(tea.Retryable(_err)) {
break
}
}
return _resp, _err
}