if name.starts_with("http://") || name.starts_with("https://") {
        debug!("unknown_remote, http = {:?}", name);
        return Ok(RemoteRepo::Http(Http {
            url: name.to_string(),
            channel: channel.to_string(),
            client: reqwest::ClientBuilder::new()
                .danger_accept_invalid_certs(no_cert_check)
                .build()?,
            name: name.to_string(),
        }));
    }
    if name.starts_with("ssh://") {
        return if let Some(mut ssh) = ssh_remote(name) {
            debug!("unknown_remote, ssh = {:?}", ssh);
            Ok(RemoteRepo::Ssh(ssh.connect(name, channel).await?))

    if let Ok(url) = url::Url::parse(name) {
        let scheme = url.scheme();
        if scheme == "http" || scheme == "https" {
            debug!("unknown_remote, http = {:?}", name);
            return Ok(RemoteRepo::Http(Http {
                url,
                channel: channel.to_string(),
                client: reqwest::ClientBuilder::new()
                    .danger_accept_invalid_certs(no_cert_check)
                    .build()?,
                name: name.to_string(),
            }));
        } else if scheme == "ssh" {
            return if let Some(mut ssh) = ssh_remote(name) {
                debug!("unknown_remote, ssh = {:?}", ssh);
                Ok(RemoteRepo::Ssh(ssh.connect(name, channel).await?))
            } else {
                bail!("Remote not found: {:?}", name)
            };

            bail!("Remote not found: {:?}", name)
        };

            bail!("Remote scheme not supported: {:?}", scheme)
        }

                let url =
                    reqwest::Url::parse(&h.url).context("failed to parse remote repository URL")?;
                if let Some(name) = libpijul::path::file_name(url.path()) {
                    Ok(Some(name.to_string()))
                } else {
                    Ok(url.host().map(|h| h.to_string()))

                if let Some(name) = libpijul::path::file_name(h.url.path()) {
                    if !name.trim().is_empty() {
                        return Ok(Some(name.trim().to_string()));
                    }

                Ok(h.url.host().map(|h| h.to_string()))

    pub url: String,

    pub url: url::Url,

    url: String,

    url: url::Url,

            let url = self.url.clone() + "/" + super::DOT_DIR;

            let url = {
                let mut p = self.url.path().to_string();
                if !p.ends_with("/") {
                    p.push('/')
                }
                p.push_str(super::DOT_DIR);
                let mut u = self.url.clone();
                u.set_path(&p);
                u
            };

                .post(&url)

                .post(url)

        let url = self.url.clone() + "/" + super::DOT_DIR;

        let url = {
            let mut p = self.url.path().to_string();
            if !p.ends_with("/") {
                p.push('/')
            }
            p.push_str(super::DOT_DIR);
            let mut u = self.url.clone();
            u.set_path(&p);
            u
        };

        let res = self.client.get(&url).query(&query).send().await?;

        let res = self.client.get(url).query(&query).send().await?;

        let url = self.url.clone() + "/" + super::DOT_DIR;
        let res = self.client.get(&url).query(&[("channel", &self.channel)]);

        let url = {
            let mut p = self.url.path().to_string();
            if !p.ends_with("/") {
                p.push('/')
            }
            p.push_str(super::DOT_DIR);
            let mut u = self.url.clone();
            u.set_path(&p);
            u
        };
        let res = self.client.get(url).query(&[("channel", &self.channel)]);

url = "2.2"

 "url",