feat: invoke git command

Author: plaflamme

gix-transport/Cargo.toml

@@ -65,7 +65,7 @@ async-client = [
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
 serde = ["dep:serde"]
 
-russh = ["dep:russh", "dep:tokio"]
+russh = ["dep:russh", "dep:tokio", "async-client", "async-std"]
 
 [[test]]
 name = "blocking-transport"

gix-transport/src/client/async_io/ssh/client.rs

@@ -1,12 +1,13 @@
 use std::{ops::DerefMut, sync::Arc, task::ready};
 
 use russh::{
-    client::Handle,
-    client::{Config, Handler},
+    client::{Config, Handle, Handler},
+    MethodSet,
 };
 
 pub enum AuthMode {
     UsernamePassword { username: String, password: String },
+    PublicKey { username: String },
 }
 
 #[derive(Clone)]
@@ -36,11 +37,40 @@ impl Client {
                     } => Err(super::Error::AuthenticationFailed(remaining_methods)),
                 }
             }
+            AuthMode::PublicKey { username } => {
+                let mut agent = russh::keys::agent::client::AgentClient::connect_env().await?;
+                let rsa_hash = handle.best_supported_rsa_hash().await?.flatten();
+                let mut methods = MethodSet::empty();
+                for key in agent.request_identities().await? {
+                    match handle
+                        .authenticate_publickey_with(&username, key, rsa_hash, &mut agent)
+                        .await?
+                    {
+                        russh::client::AuthResult::Success => return Ok(()),
+                        russh::client::AuthResult::Failure {
+                            remaining_methods,
+                            partial_success: _,
+                        } => methods = remaining_methods,
+                    }
+                }
+                Err(super::Error::AuthenticationFailed(methods))
+            }
         }
     }
 
-    pub async fn open_session(&mut self) -> Result<Session, super::Error> {
+    pub async fn open_session(
+        &mut self,
+        cmd: impl Into<String>,
+        env: Vec<(String, String)>,
+    ) -> Result<Session, super::Error> {
         let channel = self.handle.channel_open_session().await?;
+
+        for (key, value) in env {
+            channel.set_env(false, key, value).await?;
+        }
+
+        channel.exec(false, cmd.into().bytes().collect::<Vec<_>>()).await?;
+
         let stream = channel.into_stream();
         Ok(Session {
             stream: Arc::new(std::sync::Mutex::new(stream)),

gix-transport/src/client/async_io/ssh/error.rs

@@ -8,4 +8,14 @@ pub enum Error {
     AuthenticationFailed(MethodSet),
     #[error(transparent)]
     Ssh(#[from] russh::Error),
+    #[error(transparent)]
+    Keys(#[from] russh::keys::Error),
+    #[error(transparent)]
+    Agent(#[from] russh::AgentAuthError),
+}
+
+impl From<Error> for crate::client::Error {
+    fn from(err: Error) -> Self {
+        Self::NativeSshError(err)
+    }
 }

gix-transport/src/client/async_io/ssh/mod.rs

@@ -73,11 +73,26 @@ impl Transport for NativeSsh {
                 username: username.clone(),
                 password: password.clone(),
             },
-            None => return Err(crate::client::Error::AuthenticationUnsupported),
+            None => client::AuthMode::PublicKey {
+                username: self
+                    .url
+                    .user()
+                    .map(std::string::ToString::to_string)
+                    .unwrap_or_default(),
+            },
         };
 
         let mut client = client::Client::connect(host, port, auth_mode).await?;
-        let session = client.open_session().await?;
+
+        let session = client
+            .open_session(
+                format!("{} {}", service.as_str(), self.url.path),
+                vec![(
+                    "GIT_PROTOCOL".to_string(),
+                    format!("version={}", self.desired_version as usize),
+                )],
+            )
+            .await?;
 
         let connection = crate::client::git::Connection::new(
             session.clone(),

gix-transport/src/client/non_io_types.rs

@@ -149,7 +149,7 @@ mod error {
         #[error(transparent)]
         SshInvocation(SshInvocationError),
         #[error(transparent)]
-        NativeSshError(#[from] NativeSshError),
+        NativeSshError(NativeSshError),
         #[error("The repository path '{path}' could be mistaken for a command-line argument")]
         AmbiguousPath { path: BString },
     }