feat: more scaffolding

Author: plaflamme

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

@@ -40,11 +40,9 @@ pub(crate) mod function {
                     .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?,
                 )
             }
-            gix_url::Scheme::Ssh => Box::new(
-                crate::client::async_io::ssh::connect(url, options.version, options.trace)
-                    .await
-                    .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?,
-            ),
+            gix_url::Scheme::Ssh => {
+                Box::new(crate::client::async_io::ssh::connect(url, options.version, options.trace).await?)
+            }
             scheme => return Err(Error::UnsupportedScheme(scheme)),
         })
     }

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

@@ -0,0 +1,46 @@
+use std::sync::Arc;
+
+use russh::{
+    client::Handle,
+    client::{Config, Handler},
+};
+
+pub enum AuthMode {
+    UsernamePassword { username: String, password: String },
+}
+
+pub struct Client {
+    handle: Arc<Handle<ClientHandler>>,
+}
+
+impl Client {
+    pub(super) async fn connect(host: &str, port: u16, auth: AuthMode) -> Result<Self, super::Error> {
+        let mut handle = russh::client::connect(Arc::new(Config::default()), (host, port), ClientHandler).await?;
+
+        Self::authenticate(&mut handle, auth).await?;
+
+        Ok(Client {
+            handle: Arc::new(handle),
+        })
+    }
+
+    async fn authenticate(handle: &mut Handle<ClientHandler>, auth: AuthMode) -> Result<(), super::Error> {
+        match auth {
+            AuthMode::UsernamePassword { username, password } => {
+                match handle.authenticate_password(username, password).await? {
+                    russh::client::AuthResult::Success => Ok(()),
+                    russh::client::AuthResult::Failure {
+                        remaining_methods,
+                        partial_success: _,
+                    } => Err(super::Error::AuthenticationFailed(remaining_methods)),
+                }
+            }
+        }
+    }
+}
+
+struct ClientHandler;
+
+impl Handler for ClientHandler {
+    type Error = super::Error;
+}

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

@@ -0,0 +1,9 @@
+use russh::MethodSet;
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error("The authentication method failed. Remaining methods: {0:?}")]
+    AuthenticationFailed(MethodSet),
+    #[error(transparent)]
+    Ssh(#[from] russh::Error),
+}

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

@@ -1,13 +1,30 @@
-use async_trait::async_trait;
-
 use crate::{
     client::{SetServiceResponse, Transport, TransportWithoutIO},
     Protocol, Service,
 };
+use async_trait::async_trait;
 
-pub struct NativeSsh;
+mod client;
+mod error;
+
+pub use error::Error;
+
+pub struct NativeSsh {
+    url: gix_url::Url,
+    desired_version: Protocol,
+    trace: bool,
+
+    identity: Option<gix_sec::identity::Account>,
+    client: Option<client::Client>,
+    connection: Option<crate::client::git::Connection<&'static [u8], Vec<u8>>>,
+}
 
 impl TransportWithoutIO for NativeSsh {
+    fn set_identity(&mut self, identity: gix_sec::identity::Account) -> Result<(), crate::client::Error> {
+        self.identity = Some(identity);
+        Ok(())
+    }
+
     fn request(
         &mut self,
         write_mode: crate::client::WriteMode,
@@ -18,18 +35,18 @@ impl TransportWithoutIO for NativeSsh {
     }
 
     fn to_url(&self) -> std::borrow::Cow<'_, bstr::BStr> {
-        todo!()
+        self.url.to_bstring().into()
     }
 
     fn connection_persists_across_multiple_requests(&self) -> bool {
-        todo!()
+        true
     }
 
     fn configure(
         &mut self,
         config: &dyn std::any::Any,
     ) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-        todo!()
+        Ok(())
     }
 }
 
@@ -40,14 +57,59 @@ impl Transport for NativeSsh {
         service: Service,
         extra_parameters: &'a [(&'a str, Option<&'a str>)],
     ) -> Result<SetServiceResponse<'_>, crate::client::Error> {
-        todo!()
+        let host = self.url.host().expect("url has host");
+        let port = self.url.port_or_default().expect("ssh has a default port");
+
+        let auth_mode = match self.identity.as_ref() {
+            Some(crate::client::Account {
+                username,
+                password,
+                oauth_refresh_token: _,
+            }) => client::AuthMode::UsernamePassword {
+                username: username.clone(),
+                password: password.clone(),
+            },
+            None => return Err(crate::client::Error::AuthenticationUnsupported),
+        };
+
+        let client = client::Client::connect(host, port, auth_mode).await?;
+
+        let connection = crate::client::git::Connection::new(
+            [0u8].as_slice(), // TODO
+            vec![],           // TODO
+            self.desired_version,
+            self.url.path.clone(),
+            None::<(String, _)>,
+            crate::client::git::ConnectMode::Process,
+            self.trace,
+        );
+
+        self.client = Some(client);
+        self.connection = Some(connection);
+
+        self.connection
+            .as_mut()
+            .expect("connection to be there right after setting it")
+            .handshake(service, extra_parameters)
+            .await
     }
 }
 
+#[allow(clippy::unused_async)]
 pub async fn connect(
     url: gix_url::Url,
     desired_version: Protocol,
     trace: bool,
-) -> Result<NativeSsh, crate::client::Error> {
-    todo!()
+) -> Result<NativeSsh, crate::client::connect::Error> {
+    if url.scheme != gix_url::Scheme::Ssh {
+        return Err(crate::client::connect::Error::UnsupportedScheme(url.scheme));
+    }
+    Ok(NativeSsh {
+        url,
+        desired_version,
+        trace,
+        identity: None,
+        client: None,
+        connection: None,
+    })
 }

gix-transport/src/client/non_io_types.rs

@@ -93,6 +93,8 @@ mod error {
 
     use bstr::BString;
 
+    #[cfg(feature = "russh")]
+    use crate::client::async_io;
     use crate::client::capabilities;
     #[cfg(feature = "http-client")]
     use crate::client::http;
@@ -103,10 +105,14 @@ mod error {
     type HttpError = http::Error;
     #[cfg(feature = "blocking-client")]
     type SshInvocationError = ssh::invocation::Error;
+    #[cfg(feature = "russh")]
+    type NativeSshError = async_io::ssh::Error;
     #[cfg(not(feature = "http-client"))]
     type HttpError = std::convert::Infallible;
     #[cfg(not(feature = "blocking-client"))]
     type SshInvocationError = std::convert::Infallible;
+    #[cfg(not(feature = "russh"))]
+    type NativeSshError = std::convert::Infallible;
 
     /// The error used in most methods of the [`client`][crate::client] module
     #[derive(thiserror::Error, Debug)]
@@ -142,6 +148,8 @@ mod error {
         Http(#[from] HttpError),
         #[error(transparent)]
         SshInvocation(SshInvocationError),
+        #[error(transparent)]
+        NativeSshError(#[from] NativeSshError),
         #[error("The repository path '{path}' could be mistaken for a command-line argument")]
         AmbiguousPath { path: BString },
     }