Function makeOperatorRequest

cli/cluster/lib_http_client.go:173–234

(operatorConfig OperatorConfig, request *http.Request)

}

func makeOperatorRequest(operatorConfig OperatorConfig, request *http.Request) ([]byte, error) {
	if operatorConfig.Telemetry {
		values := request.URL.Query()
		values.Set("clientID", operatorConfig.ClientID)
		request.URL.RawQuery = values.Encode()
	}

	request.Header.Set("CortexAPIVersion", consts.CortexVersion)
	awsClient, err := aws.New()
	if err != nil {
		return nil, err
	}

	authHeader, err := awsClient.IdentityRequestAsHeader()
	if err != nil {
		return nil, err
	}
	request.Header.Set(consts.AuthHeader, authHeader)

	timeout := 600 * time.Second
	if request.URL.Path == "/info" {
		timeout = 10 * time.Second
	}

	client := &http.Client{
		Timeout: timeout,
		Transport: &http.Transport{
			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
		},
	}

	response, err := client.Do(request)
	if err != nil {
		return nil, ErrorFailedToConnectOperator(err, operatorConfig.EnvName, operatorConfig.OperatorEndpoint)
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		bodyBytes, err := ioutil.ReadAll(response.Body)
		if err != nil {
			return nil, errors.Wrap(err, _errStrRead)
		}

		var output schema.ErrorResponse
		err = json.Unmarshal(bodyBytes, &output)
		if err != nil || output.Message == "" {
			return nil, ErrorOperatorResponseUnknown(string(bodyBytes), response.StatusCode)
		}

		return nil, errors.WithStack(&errors.Error{
			Kind:        output.Kind,
			Message:     output.Message,
			NoTelemetry: true,
		})
	}

	bodyBytes, err := ioutil.ReadAll(response.Body)
	if err != nil {