Merge branch 'main' into gix-clone

Author: Byron

Diff for: .github/workflows/ci.yml

@@ -38,6 +38,7 @@ jobs:
     - name: Setup dependencies
       run:
         sudo apt-get install tree
+    - run: git config --global protocol.file.allow always # workaround for https://bugs.launchpad.net/ubuntu/+source/git/+bug/1993586
     - name: test
       env:
         CI: true

Diff for: git-config-value/src/path.rs

@@ -170,7 +170,7 @@ impl<'a> Path<'a> {
         Err(interpolate::Error::UserInterpolationUnsupported)
     }
 
-    #[cfg(not(windows))]
+    #[cfg(not(any(target_os = "windows", target_os = "android")))]
     fn interpolate_user(
         self,
         home_for_user: fn(&str) -> Option<PathBuf>,

Diff for: git-transport/src/client/blocking_io/http/mod.rs

@@ -21,6 +21,10 @@ mod reqwest;
 ///
 mod traits;
 
+/// The http client configuration when using reqwest
+#[cfg(feature = "http-client-reqwest")]
+pub type Options = reqwest::Options;
+
 /// The actual http client implementation, using curl
 #[cfg(feature = "http-client-curl")]
 pub type Impl = curl::Curl;

Diff for: git-transport/src/client/blocking_io/http/reqwest.rs

@@ -1,34 +1,58 @@
+pub use crate::client::http::reqwest::remote::Options;
+
 pub struct Remote {
     /// A worker thread which performs the actual request.
-    handle: Option<std::thread::JoinHandle<Result<(), reqwest::Error>>>,
+    handle: Option<std::thread::JoinHandle<Result<(), remote::Error>>>,
     /// A channel to send requests (work) to the worker thread.
     request: std::sync::mpsc::SyncSender<remote::Request>,
     /// A channel to receive the result of the prior request.
     response: std::sync::mpsc::Receiver<remote::Response>,
+    /// A mechanism for configuring the remote.
+    config: Options,
 }
 
 mod remote {
-    use std::{any::Any, convert::TryFrom, error::Error, io::Write, str::FromStr};
+    use std::sync::{Arc, Mutex};
+    use std::{any::Any, convert::TryFrom, io::Write, str::FromStr};
 
     use git_features::io::pipe;
 
     use crate::client::{http, http::reqwest::Remote};
 
+    #[derive(Debug, thiserror::Error)]
+    pub enum Error {
+        #[error(transparent)]
+        Reqwest(#[from] reqwest::Error),
+        #[error("Request configuration failed")]
+        ConfigureRequest(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
+    }
+
     impl Default for Remote {
         fn default() -> Self {
             let (req_send, req_recv) = std::sync::mpsc::sync_channel(0);
             let (res_send, res_recv) = std::sync::mpsc::sync_channel(0);
-            let handle = std::thread::spawn(move || -> Result<(), reqwest::Error> {
-                for Request { url, headers, upload } in req_recv {
+            let handle = std::thread::spawn(move || -> Result<(), Error> {
+                for Request {
+                    url,
+                    headers,
+                    upload,
+                    config,
+                } in req_recv
+                {
                     // We may error while configuring, which is expected as part of the internal protocol. The error will be
                     // received and the sender of the request might restart us.
                     let client = reqwest::blocking::ClientBuilder::new()
                         .connect_timeout(std::time::Duration::from_secs(20))
                         .build()?;
-                    let mut req = if upload { client.post(url) } else { client.get(url) }.headers(headers);
+                    let mut req_builder = if upload { client.post(url) } else { client.get(url) }.headers(headers);
                     let (post_body_tx, post_body_rx) = pipe::unidirectional(0);
                     if upload {
-                        req = req.body(reqwest::blocking::Body::new(post_body_rx));
+                        req_builder = req_builder.body(reqwest::blocking::Body::new(post_body_rx));
+                    }
+                    let mut req = req_builder.build()?;
+                    if let Some(mutex) = config.configure_request {
+                        let mut configure_request = mutex.lock().expect("our thread cannot ordinarily panic");
+                        configure_request(&mut req)?;
                     }
                     let (mut response_body_tx, response_body_rx) = pipe::unidirectional(0);
                     let (mut headers_tx, headers_rx) = pipe::unidirectional(0);
@@ -44,7 +68,7 @@ mod remote {
                         // Shut down as something is off.
                         break;
                     }
-                    let mut res = match req.send().and_then(|res| res.error_for_status()) {
+                    let mut res = match client.execute(req).and_then(|res| res.error_for_status()) {
                         Ok(res) => res,
                         Err(err) => {
                             let (kind, err) = match err.status() {
@@ -96,6 +120,7 @@ mod remote {
                 handle: Some(handle),
                 request: req_send,
                 response: res_recv,
+                config: Options::default(),
             }
         }
     }
@@ -130,6 +155,7 @@ mod remote {
                     url: url.to_owned(),
                     headers: header_map,
                     upload,
+                    config: self.config.clone(),
                 })
                 .expect("the remote cannot be down at this point");
 
@@ -181,15 +207,37 @@ mod remote {
             self.make_request(url, headers, true)
         }
 
-        fn configure(&mut self, _config: &dyn Any) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+        fn configure(&mut self, config: &dyn Any) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+            if let Some(config) = config.downcast_ref::<Options>() {
+                self.config = config.clone();
+            }
             Ok(())
         }
     }
 
+    /// Options to configure the reqwest HTTP handler.
+    #[derive(Default, Clone)]
+    pub struct Options {
+        /// A function to configure the request that is about to be made.
+        pub configure_request: Option<
+            Arc<
+                Mutex<
+                    dyn FnMut(
+                            &mut reqwest::blocking::Request,
+                        ) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>
+                        + Send
+                        + Sync
+                        + 'static,
+                >,
+            >,
+        >,
+    }
+
     pub struct Request {
         pub url: String,
         pub headers: reqwest::header::HeaderMap,
         pub upload: bool,
+        pub config: Options,
     }
 
     /// A link to a thread who provides data for the contained readers.