feat: support https push

Author: alocquet

Cargo.lock

@@ -18,6 +18,7 @@ rayon-core = "1.8"
 crossbeam-channel = "0.5"
 log = "0.4"
 thiserror = "1.0"
+url = "2.1.1"
 
 [dev-dependencies]
 tempfile = "3.1"

asyncgit/Cargo.toml

@@ -1,3 +1,4 @@
+use crate::sync::cred::BasicAuthCredential;
 use crate::{
     error::{Error, Result},
     sync, AsyncNotification, CWD,
@@ -88,6 +89,8 @@ pub struct PushRequest {
     pub remote: String,
     ///
     pub branch: String,
+    ///
+    pub basic_credential: Option<BasicAuthCredential>,
 }
 
 #[derive(Default, Clone, Debug)]
@@ -161,6 +164,7 @@ impl AsyncPush {
                 CWD,
                 params.remote.as_str(),
                 params.branch.as_str(),
+                params.basic_credential,
                 progress_sender.clone(),
             );
 

asyncgit/src/push.rs

@@ -0,0 +1,62 @@
+//! credentials git helper
+
+use git2::{Config, CredentialHelper};
+
+use crate::error::Result;
+use crate::CWD;
+
+/// basic Authentication Credentials
+#[derive(Debug, Clone, Default)]
+pub struct BasicAuthCredential {
+    ///
+    pub username: Option<String>,
+    ///
+    pub password: Option<String>,
+}
+
+/// know if username and password are needed for this url
+pub fn need_username_password(remote: &str) -> Result<bool> {
+    let repo = crate::sync::utils::repo(CWD)?;
+    let url = repo.find_remote(remote)?.url().unwrap().to_owned();
+    let is_http = url.starts_with("http");
+    Ok(is_http)
+}
+
+/// extract username and password
+pub fn extract_username_password(
+    remote: &str,
+) -> Result<BasicAuthCredential> {
+    let repo = crate::sync::utils::repo(CWD)?;
+    let url = repo.find_remote(remote)?.url().unwrap().to_owned();
+    let mut helper = CredentialHelper::new(&url);
+
+    if let Ok(config) = Config::open_default() {
+        helper.config(&config);
+    }
+    Ok(match helper.execute() {
+        Some((username, password)) => BasicAuthCredential {
+            username: Some(username),
+            password: Some(password),
+        },
+        None => extract_cred_from_url(&url),
+    })
+}
+
+/// extract credentials from url
+pub fn extract_cred_from_url(url: &str) -> BasicAuthCredential {
+    if let Ok(url) = url::Url::parse(url) {
+        BasicAuthCredential {
+            username: if url.username() == "" {
+                None
+            } else {
+                Some(url.username().to_owned())
+            },
+            password: url.password().map(|pwd| pwd.to_owned()),
+        }
+    } else {
+        BasicAuthCredential {
+            username: None,
+            password: None,
+        }
+    }
+}

asyncgit/src/sync/cred.rs

@@ -5,6 +5,7 @@ mod commit;
 mod commit_details;
 mod commit_files;
 mod commits_info;
+pub mod cred;
 pub mod diff;
 mod hooks;
 mod hunks;

asyncgit/src/sync/mod.rs

@@ -1,13 +1,16 @@
 //!
 
 use super::CommitId;
-use crate::{error::Result, sync::utils};
+use crate::{
+    error::Result, sync::cred::BasicAuthCredential, sync::utils,
+};
 use crossbeam_channel::Sender;
 use git2::{
     Cred, Error as GitError, FetchOptions, PackBuilderStage,
     PushOptions, RemoteCallbacks,
 };
 use scopetime::scope_time;
+
 ///
 #[derive(Debug, Clone)]
 pub enum ProgressNotification {
@@ -69,7 +72,7 @@ pub fn fetch_origin(repo_path: &str, branch: &str) -> Result<usize> {
     let mut remote = repo.find_remote("origin")?;
 
     let mut options = FetchOptions::new();
-    options.remote_callbacks(match remote_callbacks(None) {
+    options.remote_callbacks(match remote_callbacks(None, None) {
         Ok(callback) => callback,
         Err(e) => return Err(e),
     });
@@ -84,6 +87,7 @@ pub fn push(
     repo_path: &str,
     remote: &str,
     branch: &str,
+    basic_credential: Option<BasicAuthCredential>,
     progress_sender: Sender<ProgressNotification>,
 ) -> Result<()> {
     scope_time!("push_origin");
@@ -94,7 +98,10 @@ pub fn push(
     let mut options = PushOptions::new();
 
     options.remote_callbacks(
-        match remote_callbacks(Some(progress_sender)) {
+        match remote_callbacks(
+            Some(progress_sender),
+            basic_credential,
+        ) {
             Ok(callbacks) => callbacks,
             Err(e) => return Err(e),
         },
@@ -108,6 +115,7 @@ pub fn push(
 
 fn remote_callbacks<'a>(
     sender: Option<Sender<ProgressNotification>>,
+    basic_credential: Option<BasicAuthCredential>,
 ) -> Result<RemoteCallbacks<'a>> {
     let mut callbacks = RemoteCallbacks::new();
     let sender_clone = sender.clone();
@@ -165,21 +173,52 @@ fn remote_callbacks<'a>(
             })
         });
     });
-    callbacks.credentials(|url, username_from_url, allowed_types| {
-        log::debug!(
-            "creds: '{}' {:?} ({:?})",
-            url,
-            username_from_url,
-            allowed_types
-        );
 
-        match username_from_url {
-            Some(username) => Cred::ssh_key_from_agent(username),
-            None => Err(GitError::from_str(
-                " Couldn't extract username from url.",
-            )),
-        }
-    });
+    let mut first_call_to_credentials = true;
+    callbacks.credentials(
+        move |url, username_from_url, allowed_types| {
+            log::debug!(
+                "creds: '{}' {:?} ({:?})",
+                url,
+                username_from_url,
+                allowed_types
+            );
+            if first_call_to_credentials {
+                first_call_to_credentials = false;
+            } else {
+                return Err(GitError::from_str("Bad credentials."));
+            }
+
+            match &basic_credential {
+                _ if allowed_types.is_ssh_key() => {
+                    match username_from_url {
+                        Some(username) => {
+                            Cred::ssh_key_from_agent(username)
+                        }
+                        None => Err(GitError::from_str(
+                            " Couldn't extract username from url.",
+                        )),
+                    }
+                }
+                Some(BasicAuthCredential {
+                    username: Some(user),
+                    password: Some(pwd),
+                }) if allowed_types.is_user_pass_plaintext() => {
+                    Cred::userpass_plaintext(&user, &pwd)
+                }
+                Some(BasicAuthCredential {
+                    username: Some(user),
+                    password: _,
+                }) if allowed_types.is_username() => {
+                    Cred::username(user)
+                }
+                _ if allowed_types.is_default() => Cred::default(),
+                _ => Err(GitError::from_str(
+                    "Couldn't find credentials",
+                )),
+            }
+        },
+    );
 
     Ok(callbacks)
 }