fn request_builder()

in elasticsearch/src/http/transport.rs [497:594]
91 lines of code
10 McCabe index (conditional complexity)

    fn request_builder<B, Q>(
        &self,
        connection: &Connection,
        method: Method,
        path: &str,
        headers: HeaderMap,
        query_string: Option<&Q>,
        body: Option<B>,
        #[allow(unused_variables)] timeout: Option<Duration>,
    ) -> Result<reqwest::RequestBuilder, Error>
    where
        B: Body,
        Q: Serialize + ?Sized,
    {
        let reqwest_method = self.method(method);
        let url = connection.url.join(path.trim_start_matches('/'))?;
        let mut request_builder = self.client.request(reqwest_method, url);

        #[cfg(not(target_arch = "wasm32"))]
        if let Some(t) = timeout {
            request_builder = request_builder.timeout(t);
        }

        // set credentials before any headers, as credentials append to existing headers in reqwest,
        // whilst setting headers() overwrites, so if an Authorization header has been specified
        // on a specific request, we want it to overwrite.
        let creds_guard = self.credentials.read();
        if let Some(c) = creds_guard.as_ref() {
            request_builder = match c {
                Credentials::Basic(u, p) => request_builder.basic_auth(u, Some(p)),
                Credentials::Bearer(t) => request_builder.bearer_auth(t),
                #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
                Credentials::Certificate(_) => request_builder,
                Credentials::ApiKey(i, k) => {
                    let mut header_value = b"ApiKey ".to_vec();
                    {
                        let mut encoder = EncoderWriter::new(&mut header_value, &BASE64_STANDARD);
                        write!(encoder, "{}:", i).unwrap();
                        write!(encoder, "{}", k).unwrap();
                    }
                    let mut header_value = HeaderValue::from_bytes(&header_value).unwrap();
                    header_value.set_sensitive(true);
                    request_builder.header(AUTHORIZATION, header_value)
                }
                Credentials::EncodedApiKey(k) => {
                    let mut header_value = HeaderValue::try_from(format!("ApiKey {}", k)).unwrap();
                    header_value.set_sensitive(true);
                    request_builder.header(AUTHORIZATION, header_value)
                }
            }
        }
        drop(creds_guard);

        // default headers first, overwrite with any provided
        let mut request_headers = HeaderMap::with_capacity(4 + headers.len());
        request_headers.insert(CONTENT_TYPE, HeaderValue::from_static(DEFAULT_CONTENT_TYPE));
        request_headers.insert(ACCEPT, HeaderValue::from_static(DEFAULT_ACCEPT));
        request_headers.insert(USER_AGENT, HeaderValue::from_static(DEFAULT_USER_AGENT));
        for (name, value) in headers {
            request_headers.insert(name.unwrap(), value);
        }
        // if meta header enabled, send it last so that it's not overridden.
        if self.send_meta {
            request_headers.insert(
                "x-elastic-client-meta",
                HeaderValue::from_static(CLIENT_META.as_str()),
            );
        }

        request_builder = request_builder.headers(request_headers);

        if let Some(b) = body {
            let bytes = if let Some(bytes) = b.bytes() {
                bytes
            } else {
                let mut bytes_mut = self.bytes_mut();
                b.write(&mut bytes_mut)?;
                bytes_mut.split().freeze()
            };

            match self.request_body_compression {
                true => {
                    let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
                    encoder.write_all(&bytes)?;
                    request_builder = request_builder.body(encoder.finish()?);
                    request_builder = request_builder.header(CONTENT_ENCODING, "gzip");
                }
                false => {
                    request_builder = request_builder.body(bytes);
                }
            }
        };

        if let Some(q) = query_string {
            request_builder = request_builder.query(q);
        }
        Ok(request_builder)
    }