1 files changed, 138 insertions, 40 deletions

diff --git a/src/bin/git_remote_nostr/fetch.rs b/src/bin/git_remote_nostr/fetch.rs
index 5fd8816..6836456 100644
--- a/src/bin/git_remote_nostr/fetch.rs
+++ b/src/bin/git_remote_nostr/fetch.rs
@@ -1,10 +1,14 @@
-use std::{collections::HashMap, io::Stdin};
+use std::io::Stdin;
 
-use anyhow::{anyhow, bail, Result};
+use anyhow::{anyhow, bail, Context, Result};
 use auth_git2::GitAuthenticator;
 use git2::Repository;
 use ngit::{
-    git::{Repo, RepoActions},
+    git::{
+        nostr_url::{CloneUrl, NostrUrlDecoded, ServerProtocol},
+        utils::check_ssh_keys,
+        Repo, RepoActions,
+    },
     git_events::tag_value,
     login::get_curent_user,
     repo_ref::RepoRef,
@@ -12,12 +16,12 @@ use ngit::{
 
 use crate::utils::{
     find_proposal_and_patches_by_branch_name, get_oids_from_fetch_batch, get_open_proposals,
-    get_short_git_server_name, switch_clone_url_between_ssh_and_https,
 };
 
 pub async fn run_fetch(
     git_repo: &Repo,
     repo_ref: &RepoRef,
+    decoded_nostr_url: &NostrUrlDecoded,
     stdin: &Stdin,
     oid: &str,
     refstr: &str,
@@ -30,43 +34,19 @@ pub async fn run_fetch(
         .map(|(_, oid)| oid.clone())
         .collect::<Vec<String>>();
 
-    let mut errors = HashMap::new();
+    let mut errors = vec![];
     let term = console::Term::stderr();
 
     for git_server_url in &repo_ref.git_server {
         let term = console::Term::stderr();
-        let short_name = get_short_git_server_name(git_repo, git_server_url);
-        term.write_line(format!("fetching from {short_name}...").as_str())?;
-        let res = fetch_from_git_server(&git_repo.git_repo, &oids_from_git_servers, git_server_url);
-        term.clear_last_lines(1)?;
-        if let Err(error1) = res {
-            if let Ok(alternative_url) = switch_clone_url_between_ssh_and_https(git_server_url) {
-                let res2 = fetch_from_git_server(
-                    &git_repo.git_repo,
-                    &oids_from_git_servers,
-                    &alternative_url,
-                );
-                if let Err(error2) = res2 {
-                    term.write_line(
-                        format!(
-                            "WARNING: failed to fetch from {short_name} error:{error1}\r\nand using alternative protocol {alternative_url}: {error2}"
-                        ).as_str()
-                    )?;
-                    errors.insert(
-                        short_name.to_string(),
-                        anyhow!(
-                            "{error1} and using alternative protocol {alternative_url}: {error2}"
-                        ),
-                    );
-                } else {
-                    break;
-                }
-            } else {
-                term.write_line(
-                    format!("WARNING: failed to fetch from {short_name} error:{error1}").as_str(),
-                )?;
-                errors.insert(short_name.to_string(), error1);
-            }
+        if let Err(error) = fetch_from_git_server(
+            &git_repo.git_repo,
+            &oids_from_git_servers,
+            git_server_url,
+            decoded_nostr_url,
+            &term,
+        ) {
+            errors.push(error);
         } else {
             break;
         }
@@ -81,7 +61,7 @@ pub async fn run_fetch(
             "failed to fetch objects in nostr state event from:\r\n{}",
             errors
                 .iter()
-                .map(|(url, error)| format!("{url}: {error}"))
+                .map(std::string::ToString::to_string)
                 .collect::<Vec<String>>()
                 .join("\r\n")
         );
@@ -129,17 +109,135 @@ fn fetch_from_git_server(
     git_repo: &Repository,
     oids: &[String],
     git_server_url: &str,
+    decoded_nostr_url: &NostrUrlDecoded,
+    term: &console::Term,
 ) -> Result<()> {
-    let git_config = git_repo.config()?;
+    let server_url = git_server_url.parse::<CloneUrl>()?;
+
+    // if protocol is local - just try local
+    if server_url.protocol() == ServerProtocol::Local {
+        let formatted_url = server_url.format_as(&ServerProtocol::Local, &None)?;
+        term.write_line(format!("fetching from {formatted_url}...").as_str())?;
+        if let Err(error) = fetch_from_git_server_url(git_repo, oids, &formatted_url) {
+            term.write_line(
+                format!("WARNING: failed to fetch from {formatted_url} error:{error}").as_str(),
+            )?;
+            return Err(error).context(format!("{formatted_url}: failed to fetch"));
+        }
+        return Ok(());
+    }
+
+    term.write_line(format!("fetching from {}...", server_url.domain()).as_str())?;
+
+    // use overide protocol if specified
+    if let Some(protocol) = &decoded_nostr_url.protocol {
+        let formatted_url = server_url.format_as(protocol, &decoded_nostr_url.user)?;
+        let res = fetch_from_git_server_url(git_repo, oids, &formatted_url);
+        term.clear_last_lines(1)?;
+        if let Err(error) = res {
+            term.write_line(
+                format!(
+                    "WARNING: {formatted_url} failed to fetch over {protocol}{} as specified in nostr url. error:{error}",
+                    if let Some(user) = &decoded_nostr_url.user {
+                        format!(" with user '{user}'")
+                    } else {
+                        String::new()
+                    }
+                ).as_str(),
+            )?;
+            return Err(error).context(format!("{formatted_url}: failed to fetch"));
+        }
+        return Ok(());
+    }
+
+    // Try https unauthenticated
+    let formatted_url = server_url.format_as(&ServerProtocol::Https, &None)?;
+    let res = fetch_from_git_server_url_unauthenticated(git_repo, oids, &formatted_url);
+    term.clear_last_lines(1)?;
+    if let Err(unauth_error) = res {
+        term.write_line(
+            format!(
+                "WARNING: {formatted_url} failed to fetch over unauthenticated https. {unauth_error}",
+            ).as_str(),
+        )?;
+        // TODO what about timeout errors?
+        // try over ssh
+        let mut ssh_error = None;
+        if check_ssh_keys() {
+            term.write_line(format!("fetching from {} over ssh...", server_url.domain()).as_str())?;
+            let formatted_url = server_url.format_as(&ServerProtocol::Ssh, &None)?;
+            let res = fetch_from_git_server_url(git_repo, oids, &formatted_url);
+            term.clear_last_lines(1)?;
+            if let Err(error) = res {
+                term.write_line(
+                    format!("WARNING: {formatted_url} failed to fetch over ssh. error:{error}")
+                        .as_str(),
+                )?;
+                term.write_line(
+                    format!("fetching from {} over ssh...", server_url.domain()).as_str(),
+                )?;
+                ssh_error = Some(error);
+            } else {
+                return Ok(());
+            }
+        }
+        // try over https authenticated
+        term.write_line(
+            format!(
+                "fetching from {} over authenticated https...",
+                server_url.domain()
+            )
+            .as_str(),
+        )?;
+        let formatted_url = server_url.format_as(&ServerProtocol::Ssh, &None)?;
+        let res = fetch_from_git_server_url(git_repo, oids, &formatted_url);
+        term.clear_last_lines(1)?;
+        if let Err(auth_https_error) = res {
+            term.write_line(
+                format!("WARNING: {formatted_url} failed to fetch over authenticated https. error:{auth_https_error}",)
+                    .as_str(),
+            )?;
+            let error_message = format!(
+                "{} failed to fetch over unauthenticated https ({unauth_error}), ssh ({}) and authenticated https ({auth_https_error})",
+                server_url.format_as(&ServerProtocol::Unspecified, &None)?,
+                ssh_error.unwrap_or(anyhow!("no keys found"))
+            );
+
+            bail!(error_message)
+        }
+    }
+    Ok(())
+}
 
+fn fetch_from_git_server_url(
+    git_repo: &Repository,
+    oids: &[String],
+    git_server_url: &str,
+) -> Result<()> {
+    let git_config = git_repo.config()?;
     let mut git_server_remote = git_repo.remote_anonymous(git_server_url)?;
-    // authentication may be required (and will be requird if clone url is ssh)
     let auth = GitAuthenticator::default();
     let mut fetch_options = git2::FetchOptions::new();
     let mut remote_callbacks = git2::RemoteCallbacks::new();
+    // TODO status update callback
     remote_callbacks.credentials(auth.credentials(&git_config));
     fetch_options.remote_callbacks(remote_callbacks);
     git_server_remote.download(oids, Some(&mut fetch_options))?;
     git_server_remote.disconnect()?;
     Ok(())
 }
+
+fn fetch_from_git_server_url_unauthenticated(
+    git_repo: &Repository,
+    oids: &[String],
+    git_server_url: &str,
+) -> Result<()> {
+    let mut git_server_remote = git_repo.remote_anonymous(git_server_url)?;
+    let mut fetch_options = git2::FetchOptions::new();
+    let remote_callbacks = git2::RemoteCallbacks::new();
+    // TODO status update callback
+    fetch_options.remote_callbacks(remote_callbacks);
+    git_server_remote.download(oids, Some(&mut fetch_options))?;
+    git_server_remote.disconnect()?;
+    Ok(())
+}