func()

in client/client.go [500:622]

• 113 lines of code
• 16 McCabe index (conditional complexity)

func (client *Client) _request(method *string, pathname *string, query map[string]interface{}, headers map[string]*string, body interface{}, runtime *util.RuntimeOptions) (_result map[string]interface{}, _err error) {
	_err = tea.Validate(runtime)
	if _err != nil {
		return _result, _err
	}
	_runtime := map[string]interface{}{
		"timeouted":      "retry",
		"readTimeout":    tea.IntValue(runtime.ReadTimeout),
		"connectTimeout": tea.IntValue(runtime.ConnectTimeout),
		"httpProxy":      tea.StringValue(runtime.HttpProxy),
		"httpsProxy":     tea.StringValue(runtime.HttpsProxy),
		"noProxy":        tea.StringValue(runtime.NoProxy),
		"maxIdleConns":   tea.IntValue(runtime.MaxIdleConns),
		"retry": map[string]interface{}{
			"retryable":   tea.BoolValue(runtime.Autoretry),
			"maxAttempts": tea.IntValue(util.DefaultNumber(runtime.MaxAttempts, tea.Int(5))),
		},
		"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, tea.String("HTTP"))
			request_.Method = method
			request_.Pathname = pathname
			request_.Headers = tea.Merge(map[string]*string{
				"user-agent":    client.GetUserAgent(),
				"host":          util.DefaultString(client.Endpoint, tea.String(tea.StringValue(client.InstanceId)+"."+tea.StringValue(client.Domainsuffix))),
				"authorization": tea.String("Basic " + tea.StringValue(client.Credential)),
				"content-type":  tea.String("application/json; charset=utf-8"),
			}, headers)
			if !tea.BoolValue(util.IsUnset(query)) {
				request_.Query = util.StringifyMapValue(query)
				request_.Headers["X-Opensearch-Request-ID"] = util.GetNonce()
			}

			if !tea.BoolValue(util.IsUnset(body)) {
				request_.Headers["X-Opensearch-Swift-Request-ID"] = util.GetNonce()
				request_.Body = tea.ToReader(util.ToJSONString(body))
			}

			response_, _err := tea.DoRequest(request_, _runtime)
			if _err != nil {
				return _result, _err
			}
			objStr, _err := util.ReadAsString(response_.Body)
			if _err != nil {
				return _result, _err
			}

			if tea.BoolValue(util.Is4xx(response_.StatusCode)) || tea.BoolValue(util.Is5xx(response_.StatusCode)) {
				var rawMsg interface{}
				_, tryErr := func() (_r map[string]interface{}, _e error) {
					defer func() {
						if r := tea.Recover(recover()); r != nil {
							_e = r
						}
					}()
					rawMsg = util.ParseJSON(objStr)

					return nil, nil
				}()

				if tryErr != nil {
					var err = &tea.SDKError{}
					if _t, ok := tryErr.(*tea.SDKError); ok {
						err = _t
					} else {
						err.Message = tea.String(tryErr.Error())
					}
					rawMsg = objStr
				}
				rawMap := map[string]interface{}{
					"errors": rawMsg,
				}
				_err = tea.NewSDKError(map[string]interface{}{
					"message": tea.StringValue(response_.StatusMessage),
					"data":    rawMap,
					"code":    tea.IntValue(response_.StatusCode),
				})
				return _result, _err
			}

			if tea.BoolValue(util.Empty(objStr)) {
				rawbodyMap := map[string]interface{}{
					"status": tea.StringValue(response_.StatusMessage),
					"code":   tea.IntValue(response_.StatusCode),
				}
				_result = make(map[string]interface{})
				_err = tea.Convert(map[string]interface{}{
					"body":    tea.StringValue(util.ToJSONString(rawbodyMap)),
					"headers": response_.Headers,
				}, &_result)
				return _result, _err
			}

			_result = make(map[string]interface{})
			_err = tea.Convert(map[string]interface{}{
				"body":    tea.StringValue(objStr),
				"headers": response_.Headers,
			}, &_result)
			return _result, _err
		}()
		if !tea.BoolValue(tea.Retryable(_err)) {
			break
		}
	}

	return _resp, _err
}