func()

in private/requestcompression/request_compression.go [52:103]

• 45 lines of code
• 13 McCabe index (conditional complexity)

func (m requestCompression) HandleSerialize(
	ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler,
) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	if m.disableRequestCompression {
		return next.HandleSerialize(ctx, in)
	}
	// still need to check requestMinCompressSizeBytes in case it is out of range after service client config
	if m.requestMinCompressSizeBytes < 0 || m.requestMinCompressSizeBytes > MaxRequestMinCompressSizeBytes {
		return out, metadata, fmt.Errorf("invalid range for min request compression size bytes %d, must be within 0 and 10485760 inclusively", m.requestMinCompressSizeBytes)
	}

	req, ok := in.Request.(*http.Request)
	if !ok {
		return out, metadata, fmt.Errorf("unknown request type %T", req)
	}

	for _, algorithm := range m.compressAlgorithms {
		compressFunc := allowedAlgorithms[algorithm]
		if compressFunc != nil {
			if stream := req.GetStream(); stream != nil {
				size, found, err := req.StreamLength()
				if err != nil {
					return out, metadata, fmt.Errorf("error while finding request stream length, %v", err)
				} else if !found || size < m.requestMinCompressSizeBytes {
					return next.HandleSerialize(ctx, in)
				}

				compressedBytes, err := compressFunc(stream)
				if err != nil {
					return out, metadata, fmt.Errorf("failed to compress request stream, %v", err)
				}

				var newReq *http.Request
				if newReq, err = req.SetStream(bytes.NewReader(compressedBytes)); err != nil {
					return out, metadata, fmt.Errorf("failed to set request stream, %v", err)
				}
				*req = *newReq

				if val := req.Header.Get("Content-Encoding"); val != "" {
					req.Header.Set("Content-Encoding", fmt.Sprintf("%s, %s", val, algorithm))
				} else {
					req.Header.Set("Content-Encoding", algorithm)
				}
			}
			break
		}
	}

	return next.HandleSerialize(ctx, in)
}