laumann/pijul - Change H4AU6QRPRDRFW3V7NN5CJ6DHLEUBYGNLRZ5GYV6ULBGRMOPCJQXQC

New config for HTTP remotes

Created by pmeunier on November 11, 2022

H4AU6QRPRDRFW3V7NN5CJ6DHLEUBYGNLRZ5GYV6ULBGRMOPCJQXQC

Dependencies

In channels

main

Change contents

Replacement in pijul/src/remote/mod.rs at line 53 [5.52474]

B:BD[5.53148] → [5.53148:53208]

B:BD[5.53208] → [6.54:82]

        if let Some(name) = self.config.remotes.get(name) {
            unknown_remote(

[5.53148]

[6.82]

        if let Some(name) = self.config.remotes.iter().find(|e| e.name() == name) {
            name.to_remote(channel, no_cert_check, with_path).await
            /*unknown_remote(

Replacement in pijul/src/remote/mod.rs at line 62 [5.52474]
B:BD[6.248] → [6.248:267]
```
            .await
```
[6.248]
[5.53271]
```
            .await*/
```

Insertion in pijul/src/remote/mod.rs at line 69 [5.52474]

[5.53370]

impl RemoteConfig {
    async fn to_remote(
        &self,
        channel: &str,
        no_cert_check: bool,
        with_path: bool,
    ) -> Result<RemoteRepo, anyhow::Error> {
        match self {
            RemoteConfig::Ssh { ssh, .. } => {
                if let Some(mut sshr) = ssh_remote(ssh, with_path) {
                    debug!("unknown_remote, ssh = {:?}", ssh);
                    if let Some(c) = sshr.connect(ssh, channel).await? {
                        return Ok(RemoteRepo::Ssh(c));
                    }
                }
                bail!("Remote not found: {:?}", ssh)
            }
            RemoteConfig::Http {
                http,
                headers,
                name,
            } => {
                let mut h = Vec::new();
                for (k, v) in headers.iter() {
                    match v {
                        RemoteHttpHeader::String(s) => {
                            h.push((k.clone(), s.clone()));
                        }
                        RemoteHttpHeader::Shell(shell) => {
                            h.push((k.clone(), shell_cmd(&shell.shell)?));
                        }
                    }
                }
                return Ok(RemoteRepo::Http(Http {
                    url: http.parse().unwrap(),
                    channel: channel.to_string(),
                    client: reqwest::ClientBuilder::new()
                        .danger_accept_invalid_certs(no_cert_check)
                        .build()?,
                    headers: h,
                    name: name.to_string(),
                }));
            }
        }
    }
}

Insertion in pijul/src/remote/mod.rs at line 133 [5.52474]
[7.450]
[7.450]
```
                headers: Vec::new(),
```
Deletion in pijul/src/remote/http.rs at line 1 [8.10]
B:BD[8.10] → [9.4982:5013]
∅:D[10.1080] → [8.11:55]
∅:D[9.5013] → [8.11:55]
B:BD[8.10] → [8.11:55]
B:BD[8.55] → [11.1192:1193]
```
use std::collections::HashSet;
use std::io::Write;
use std::path::PathBuf;
```

Insertion in pijul/src/remote/http.rs at line 5 [8.10]

[12.32]

[2.23928]

use std::collections::HashSet;
use std::io::Write;
use std::path::PathBuf;

Insertion in pijul/src/remote/http.rs at line 18 [8.10]
[8.207]
[13.26]
```
    pub headers: Vec<(String, String)>,
```
Insertion in pijul/src/remote/http.rs at line 24 [8.10]
[7.1215]
[13.101]
```
    headers: Vec<(String, String)>,
```
Insertion in pijul/src/remote/http.rs at line 64 [8.10]
[12.650]
[12.650]
Replacement in pijul/src/remote/http.rs at line 67 [8.10]
∅:D[12.694] → [14.70:116]
B:BD[15.11] → [14.70:116]
```
        let mut res = if let Ok(res) = client
```
[12.694]
[14.116]
```
        let mut req = client
```

Replacement in pijul/src/remote/http.rs at line 70 [8.10]

∅:D[2.24506] → [14.179:289]

B:BD[14.179] → [14.179:289]

            .header(reqwest::header::USER_AGENT, USER_AGENT)
            .send()
            .await
        {

[2.24506]

[16.173]

            .header(reqwest::header::USER_AGENT, USER_AGENT);
        for (k, v) in headers.iter() {
            req = req.header(k.as_str(), v.as_str());
        }
        let mut res = if let Ok(res) = req.send().await {

Insertion in pijul/src/remote/http.rs at line 156 [8.10]
[13.1740]
[13.1740]
```
                    self.headers.clone(),
```
Replacement in pijul/src/remote/http.rs at line 233 [8.10]
B:BD[17.1639] → [18.0:28]
```
            let resp = self
```
[17.1639]
[18.28]
```
            let mut req = self
```

Replacement in pijul/src/remote/http.rs at line 237 [8.10]

B:BD[17.1727] → [14.290:355]

B:BD[14.355] → [2.25772:25800]

∅:D[2.25800] → [17.1757:1781]

B:BD[17.1757] → [17.1757:1781]

∅:D[19.1378] → [17.1781:1806]

B:BD[17.1781] → [17.1781:1806]

                .header(reqwest::header::USER_AGENT, USER_AGENT)
                .body(body)
                .send()
                .await?;

[17.1727]

[18.53]

                .header(reqwest::header::USER_AGENT, USER_AGENT);
            for (k, v) in self.headers.iter() {
                req = req.header(k.as_str(), v.as_str());
            }
            let resp = req.body(body).send().await?;

Replacement in pijul/src/remote/http.rs at line 285 [8.10]
B:BD[9.5584] → [14.356:379]
```
        let res = self
```
[9.5584]
[14.379]
```
        let mut req = self
```

Replacement in pijul/src/remote/http.rs at line 289 [8.10]

B:BD[14.448] → [14.448:550]

            .header(reqwest::header::USER_AGENT, USER_AGENT)
            .send()
            .await?;

[14.448]

[20.0]

            .header(reqwest::header::USER_AGENT, USER_AGENT);
        for (k, v) in self.headers.iter() {
            req = req.header(k.as_str(), v.as_str());
        }
        let res = req.send().await?;

Replacement in pijul/src/remote/http.rs at line 341 [8.10]
B:BD[21.683] → [14.551:574]
```
        let res = self
```
[21.683]
[14.574]
```
        let mut req = self
```

Replacement in pijul/src/remote/http.rs at line 345 [8.10]

B:BD[14.640] → [14.640:742]

            .header(reqwest::header::USER_AGENT, USER_AGENT)
            .send()
            .await?;

[14.640]

[21.757]

            .header(reqwest::header::USER_AGENT, USER_AGENT);
        for (k, v) in self.headers.iter() {
            req = req.header(k.as_str(), v.as_str());
        }
        let res = req.send().await?;

Replacement in pijul/src/remote/http.rs at line 374 [8.10]
B:BD[22.10720] → [22.10720:10743]
```
        let res = self
```
[22.10720]
[22.10743]
```
        let mut req = self
```

Replacement in pijul/src/remote/http.rs at line 378 [8.10]

B:BD[22.10809] → [22.10809:10911]

            .header(reqwest::header::USER_AGENT, USER_AGENT)
            .send()
            .await?;

[22.10809]

[22.10911]

            .header(reqwest::header::USER_AGENT, USER_AGENT);
        for (k, v) in self.headers.iter() {
            req = req.header(k.as_str(), v.as_str());
        }
        let res = req.send().await?;

Replacement in pijul/src/remote/http.rs at line 459 [8.10]
B:BD[22.11594] → [22.11594:11617]
```
        let res = self
```
[22.11594]
[22.11617]
```
        let mut req = self
```

Replacement in pijul/src/remote/http.rs at line 470 [8.10]

B:BD[22.11886] → [22.11886:11988]

            .header(reqwest::header::USER_AGENT, USER_AGENT)
            .send()
            .await?;

[22.11886]

[22.11988]

            .header(reqwest::header::USER_AGENT, USER_AGENT);
        for (k, v) in self.headers.iter() {
            req = req.header(k.as_str(), v.as_str());
        }
        let res = req.send().await?;

Replacement in pijul/src/main.rs at line 153 [5.83981]

B:BD[4.434] → [4.434:496]

        log::error!("Error backtrace: {:#?}", e.backtrace());

[4.434]

[23.0]

        log::error!("Error: {:#?}", e);

Replacement in pijul/src/config.rs at line 134 [5.89866]
B:BD[24.22] → [6.308:354]
```
    pub remotes: HashMap<String, RemoteName>,
```
[24.22]
[24.23]
```
    pub remotes: Vec<RemoteConfig>,
```

Replacement in pijul/src/config.rs at line 142 [5.89866]

B:BD[6.358] → [3.459:487]

∅:D[3.487] → [6.375:439]

B:BD[6.375] → [6.375:439]

#[derive(Debug, Serialize)]
pub enum RemoteName {
    Name(String),
    Split(SplitRemote),

[6.358]

[6.439]

#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RemoteConfig {
    Ssh {
        name: String,
        ssh: String,
    },
    Http {
        name: String,
        http: String,
        #[serde(default)]
        headers: HashMap<String, RemoteHttpHeader>,
    },

Replacement in pijul/src/config.rs at line 157 [5.89866]

B:BD[6.442] → [6.442:794]

#[derive(Clone, Copy, Debug)]
pub enum Direction {
    Push,
    Pull,
}
impl RemoteName {
    pub fn with_dir(&self, d: Direction) -> &str {
        match (self, d) {
            (RemoteName::Name(ref s), _) => s,
            (RemoteName::Split(ref s), Direction::Pull) => &s.pull,
            (RemoteName::Split(ref s), Direction::Push) => &s.push,

[6.442]

[6.794]

impl RemoteConfig {
    pub fn name(&self) -> &str {
        match self {
            RemoteConfig::Ssh { name, .. } => name,
            RemoteConfig::Http { name, .. } => name,

Deletion in pijul/src/config.rs at line 165 [5.89866]

B:BD[6.812] → [6.812:1608]


use serde::de::{self, MapAccess, Visitor};
use serde::de::{Deserialize, Deserializer};
use std::fmt;
use std::marker::PhantomData;
impl<'de> Deserialize<'de> for RemoteName {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct StringOrStruct(PhantomData<fn() -> RemoteName>);
        impl<'de> Visitor<'de> for StringOrStruct {
            type Value = RemoteName;
            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("string or map")
            }
            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
            where
                E: de::Error,
            {
                Ok(RemoteName::Name(value.to_string()))
            }

Replacement in pijul/src/config.rs at line 166 [5.89866]

B:BD[6.1609] → [6.1609:2296]

            fn visit_map<M>(self, map: M) -> Result<Self::Value, M::Error>
            where
                M: MapAccess<'de>,
            {
                // `MapAccessDeserializer` is a wrapper that turns a `MapAccess`
                // into a `Deserializer`, allowing it to be used as the input to T's
                // `Deserialize` implementation. T then deserializes itself using
                // the entries from the map visitor.
                Ok(RemoteName::Split(Deserialize::deserialize(
                    de::value::MapAccessDeserializer::new(map),
                )?))
            }
        }
        deserializer.deserialize_any(StringOrStruct(PhantomData))
    }

[6.1609]

[5.91196]

#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RemoteHttpHeader {
    String(String),
    Shell(Shell),

Replacement in pijul/src/config.rs at line 174 [5.89866]

∅:D[3.529] → [6.2327:2396]

B:BD[6.2327] → [6.2327:2396]

pub struct SplitRemote {
    pub pull: String,
    pub push: String,

[3.529]

[6.2396]

pub struct Shell {
    pub shell: String,
}
#[derive(Clone, Copy, Debug)]
pub enum Direction {
    Push,
    Pull,

Insertion in pijul/src/config.rs at line 199 [5.89866]

[25.217]

pub fn shell_cmd(s: &str) -> Result<String, anyhow::Error> {
    let out = if cfg!(target_os = "windows") {
        std::process::Command::new("cmd")
            .args(&["/C", s])
            .output()
            .expect("failed to execute process")
    } else {
        std::process::Command::new(std::env::var("SHELL").unwrap_or("sh".to_string()))
            .arg("-c")
            .arg(s)
            .output()
            .expect("failed to execute process")
    };
    Ok(String::from_utf8(out.stdout)?)
}

New config for HTTP remotes

Dependencies

In channels

Change contents

Replacement in pijul/src/remote/mod.rs at line 53 [5.52474]

Replacement in pijul/src/remote/mod.rs at line 62 [5.52474]

Insertion in pijul/src/remote/mod.rs at line 69 [5.52474]

Insertion in pijul/src/remote/mod.rs at line 133 [5.52474]

Deletion in pijul/src/remote/http.rs at line 1 [8.10]

Insertion in pijul/src/remote/http.rs at line 5 [8.10]

Insertion in pijul/src/remote/http.rs at line 18 [8.10]

Insertion in pijul/src/remote/http.rs at line 24 [8.10]

Insertion in pijul/src/remote/http.rs at line 64 [8.10]

Replacement in pijul/src/remote/http.rs at line 67 [8.10]

Replacement in pijul/src/remote/http.rs at line 70 [8.10]

Insertion in pijul/src/remote/http.rs at line 156 [8.10]

Replacement in pijul/src/remote/http.rs at line 233 [8.10]