func()

in http_client.go [97:172]

• 51 lines of code
• 12 McCabe index (conditional complexity)

func (c *httpClient) post(ctx context.Context, message proto.Message) (proto.Message, error) {

	wrapped, err := proto.Marshal(message)

	if err != nil {
		return nil, fmt.Errorf("error marshaling request message to protobuf: %w", err)
	}

	wire := avaticaMessage.WireMessage_builder{
		Name:           classNameFromRequest(message),
		WrappedMessage: wrapped,
	}.Build()

	body, err := proto.Marshal(wire)

	if err != nil {
		return nil, fmt.Errorf("error marshaling wire message to protobuf: %w", err)
	}

	req, err := http.NewRequest("POST", c.host, bytes.NewReader(body))

	if err != nil {
		return nil, fmt.Errorf("error creating http request: %w", err)
	}

	req.Header.Set("Content-Type", "application/x-google-protobuf")

	req = req.WithContext(ctx)

	res, err := c.httpClient.Do(req)

	if err != nil {
		return nil, fmt.Errorf("error executing http request: %w", err)
	}

	defer res.Body.Close()

	response, err := io.ReadAll(res.Body)

	if err != nil {
		return nil, fmt.Errorf("error reading response body: %w", err)
	}

	result := &avaticaMessage.WireMessage{}

	err = proto.Unmarshal(response, result)

	if err != nil {
		return nil, fmt.Errorf("error unmarshaling wire message: %w", err)
	}

	inner, err := responseFromClassName(result.GetName())

	if err != nil {
		return nil, fmt.Errorf("error getting wrapped response from wire message: %w", err)
	}

	err = proto.Unmarshal(result.GetWrappedMessage(), inner)

	if err != nil {
		return nil, fmt.Errorf("error unmarshaling wrapped message: %w", err)
	}

	if v, ok := inner.(*avaticaMessage.ErrorResponse); ok {

		for _, exception := range v.GetExceptions() {
			if badConnRe.MatchString(exception) {
				return nil, driver.ErrBadConn
			}
		}

		return nil, avaticaError{v}
	}

	return inner, nil
}