alagopus/pijul-test - Change 76PCXGML77EZWTRI5E6KHLVRAFTJ2AB5YRN5EKOYNAPKTWY2KCGAC

Pushing to, and pulling from the local repository

Created by pmeunier on November 17, 2020

76PCXGML77EZWTRI5E6KHLVRAFTJ2AB5YRN5EKOYNAPKTWY2KCGAC

Dependencies

[2] SXEYMYF7P4RZMZ46WPL4IZUTSQ2ATBWYZX7QNVMS3SGOYXYOHAGQC

In channels

main

Change contents

Insertion in pijul/src/remote/mod.rs at line 18 [2.52474]
[2.52838]
[2.52838]
```
    LocalChannel(String),
```
Insertion in pijul/src/remote/mod.rs at line 32 [2.52474]
[2.53031]
[2.53031]
```
        self_path: Option<&Path>,
```

Replacement in pijul/src/remote/mod.rs at line 38 [2.52474]

B:BD[2.53208] → [2.53208:53271]

            unknown_remote(name, channel, no_cert_check).await

[2.53208]

[2.53271]

            unknown_remote(self_path, name, channel, no_cert_check).await

Replacement in pijul/src/remote/mod.rs at line 40 [2.52474]

B:BD[2.53288] → [2.53288:53351]

            unknown_remote(name, channel, no_cert_check).await

[2.53288]

[2.53351]

            unknown_remote(self_path, name, channel, no_cert_check).await

Insertion in pijul/src/remote/mod.rs at line 46 [2.52474]
[2.53399]
[2.53399]
```
    self_path: Option<&Path>,
```
Replacement in pijul/src/remote/mod.rs at line 53 [2.52474]
B:BD[2.53622] → [2.53622:53657]
```
        Ok(RemoteRepo::Http(Http {
```
[2.53622]
[2.53657]
```
        return Ok(RemoteRepo::Http(Http {
```

Replacement in pijul/src/remote/mod.rs at line 60 [2.52474]

B:BD[2.53907] → [2.53907:54008]

        }))
    } else if name.starts_with("ssh://") {
        if let Some(ssh) = ssh_remote(name) {

[2.53907]

[2.54008]

        }));
    }
    if name.starts_with("ssh://") {
        return if let Some(ssh) = ssh_remote(name) {

Insertion in pijul/src/remote/mod.rs at line 71 [2.52474]

[2.54266]

        };
    }
    if let Ok(root) = std::fs::canonicalize(name) {
        if let Some(path) = self_path {
            let path = std::fs::canonicalize(path)?;
            if path == root {
                return Ok(RemoteRepo::LocalChannel(channel.to_string()));
            }

Replacement in pijul/src/remote/mod.rs at line 80 [2.52474]

B:BD[2.54276] → [2.54276:54346]

    } else {
        let mut dot_dir = Path::new(name).join(DOT_DIR);

[2.54276]

[2.54346]


        let mut dot_dir = root.join(DOT_DIR);

Replacement in pijul/src/remote/mod.rs at line 88 [2.52474]

B:BD[2.54603] → [2.54603:54644]

            Ok(RemoteRepo::Local(Local {

[2.54603]

[2.54644]

            return Ok(RemoteRepo::Local(Local {

Replacement in pijul/src/remote/mod.rs at line 94 [2.52474]

B:BD[2.54838] → [2.54838:55165]

            }))
        } else if let Some(ssh) = ssh_remote(name) {
            debug!("unknown_remote, ssh = {:?}", ssh);
            Ok(RemoteRepo::Ssh(ssh.connect(name, channel).await?))
        } else {
            Err((Error::RemoteNotFound {
                remote: name.to_string(),
            })
            .into())

[2.54838]

[2.55165]

            }));

Insertion in pijul/src/remote/mod.rs at line 97 [2.52474]

[2.55181]

    if let Some(ssh) = ssh_remote(name) {
        debug!("unknown_remote, ssh = {:?}", ssh);
        Ok(RemoteRepo::Ssh(ssh.connect(name, channel).await?))
    } else {
        Err((Error::RemoteNotFound {
            remote: name.to_string(),
        })
        .into())
    }

Replacement in pijul/src/remote/mod.rs at line 109 [2.52474]
B:BD[2.55202] → [2.55202:55231]
```
    fn name(&self) -> &str {
```
[2.55202]
[2.55231]
```
    fn name(&self) -> Option<&str> {
```

Replacement in pijul/src/remote/mod.rs at line 111 [2.52474]

B:BD[2.55253] → [2.55253:55421]

            RemoteRepo::Ssh(ref s) => s.name.as_str(),
            RemoteRepo::Local(ref l) => l.name.as_str(),
            RemoteRepo::Http(ref h) => h.name.as_str(),

[2.55253]

[2.55421]

            RemoteRepo::Ssh(ref s) => Some(s.name.as_str()),
            RemoteRepo::Local(ref l) => Some(l.name.as_str()),
            RemoteRepo::Http(ref h) => Some(h.name.as_str()),
            RemoteRepo::LocalChannel(_) => None,

Insertion in pijul/src/remote/mod.rs at line 143 [2.52474]
[2.56425]
[2.56425]
```
            RemoteRepo::LocalChannel(_) => None,
```

Replacement in pijul/src/remote/mod.rs at line 156 [2.52474]

B:BD[2.56691] → [2.56691:56739]

    pub async fn update_changelist<T: MutTxnT>(

[2.56691]

[2.56739]

    pub async fn update_changelist<T: MutTxnT + TxnTExt>(

Replacement in pijul/src/remote/mod.rs at line 160 [2.52474]
B:BD[2.56804] → [2.56804:56851]
```
    ) -> Result<RemoteRef<T>, anyhow::Error> {
```
[2.56804]
[2.56851]
```
    ) -> Result<Option<RemoteRef<T>>, anyhow::Error> {
```

Replacement in pijul/src/remote/mod.rs at line 162 [2.52474]

B:BD[2.56888] → [2.56888:56920]

        let name = self.name();

[2.56888]

[2.56920]

        let name = if let Some(name) = self.name() {
            name
        } else {
            return Ok(None);
        };

Replacement in pijul/src/remote/mod.rs at line 181 [2.52474]
B:BD[2.57497] → [2.57497:57516]
```
        Ok(remote)
```
[2.57497]
[2.57516]
```
        Ok(Some(remote))
```

Replacement in pijul/src/remote/mod.rs at line 184 [2.52474]

B:BD[2.57523] → [2.57523:57570]

    async fn dichotomy_changelist<T: MutTxnT>(

[2.57523]

[2.57570]

    async fn dichotomy_changelist<T: MutTxnT + TxnTExt>(

Replacement in pijul/src/remote/mod.rs at line 196 [2.52474]

B:BD[2.57913] → [2.57913:57976]

        if let Some((_, s)) = self.get_state(Some(b)).await? {

[2.57913]

[2.57976]

        if let Some((_, s)) = self.get_state(txn, Some(b)).await? {

Replacement in pijul/src/remote/mod.rs at line 208 [2.52474]

B:BD[2.58438] → [2.58438:58503]

            let remote_state = self.get_state(Some(mid)).await?;

[2.58438]

[2.58503]

            let remote_state = self.get_state(txn, Some(mid)).await?;

Replacement in pijul/src/remote/mod.rs at line 229 [2.52474]
B:BD[2.59045] → [2.59045:59069]
```
    async fn get_state(
```
[2.59045]
[2.59069]
```
    async fn get_state<T: libpijul::TxnTExt>(
```
Insertion in pijul/src/remote/mod.rs at line 231 [2.52474]
[2.59088]
[2.59088]
```
        txn: &T,
```

Insertion in pijul/src/remote/mod.rs at line 268 [2.52474]

[2.60604]

            RemoteRepo::LocalChannel(ref channel) => {
                if let Some(channel) = txn.load_channel(&channel) {
                    Ok(local::get_state(txn, &channel, mid))
                } else {
                    Ok(None)
                }
            }

Insertion in pijul/src/remote/mod.rs at line 341 [2.52474]
[2.63484]
[2.63484]
```
            RemoteRepo::LocalChannel(_) => unreachable!(),
```
Insertion in pijul/src/remote/mod.rs at line 383 [2.52474]
[2.65082]
[2.65082]
```
            RemoteRepo::LocalChannel(_) => Ok(()),
```

Replacement in pijul/src/remote/mod.rs at line 388 [2.52474]

B:BD[2.65147] → [2.65147:65180]

    pub async fn upload_changes(

[2.65147]

[2.65180]

    pub async fn upload_changes<T: MutTxnTExt, W: libpijul::working_copy::WorkingCopy>(

Insertion in pijul/src/remote/mod.rs at line 390 [2.52474]
[2.65199]
[2.65199]
```
        repo: &mut W,
        txn: &mut T,
```

Insertion in pijul/src/remote/mod.rs at line 422 [2.52474]

[2.66522]

            RemoteRepo::LocalChannel(ref channel) => {
                let mut channel = txn.open_or_create_channel(channel)?;
                let store = libpijul::changestore::filesystem::FileSystem::from_changes(local);
                local::upload_changes(&store, repo, txn, &mut channel, changes)
            }

Insertion in pijul/src/remote/mod.rs at line 464 [2.52474]
[2.68044]
[2.68044]
```
            RemoteRepo::LocalChannel(_) => {}
```
Replacement in pijul/src/remote/mod.rs at line 616 [2.52474]
B:BD[2.73321] → [2.73321:73353]
```
        let name = self.name();
```
[2.73321]
[2.73353]
```
        let name = self.name().unwrap();
```

Replacement in pijul/src/remote/mod.rs at line 755 [2.52474]

B:BD[2.78229] → [2.78229:78300]

        let remote_changes = self.update_changelist(txn, path).await?;

[2.78229]

[2.78300]

        let remote_changes = self
            .update_changelist(txn, path)
            .await?
            .expect("Remote is not self");

Insertion in pijul/src/remote/local.rs at line 11 [2.79745]

[2.80101]

}
pub fn get_state<T: TxnTExt>(
    txn: &T,
    channel: &libpijul::pristine::ChannelRef<T>,
    mid: Option<u64>,
) -> Option<(u64, Merkle)> {
    if let Some(mid) = mid {
        txn.get_changes(&channel, mid).map(|(_, m)| (mid, m))
    } else {
        txn.reverse_log(&channel.borrow(), None)
            .next()
            .map(|(n, (_, m))| (n, m))
    }

Replacement in pijul/src/remote/local.rs at line 31 [2.79745]

B:BD[2.80327] → [2.80327:80598]

        if let Some(mid) = mid {
            Ok(txn.get_changes(&channel, mid).map(|(_, m)| (mid, m)))
        } else {
            Ok(txn
                .reverse_log(&channel.borrow(), None)
                .next()
                .map(|(n, (_, m))| (n, m)))
        }

[2.80327]

[2.80598]

        Ok(get_state(&txn, &channel, mid))

Deletion in pijul/src/remote/local.rs at line 85 [2.79745]
B:BD[2.82503] → [2.82503:82557]
```
        let mut ws = libpijul::ApplyWorkspace::new();
```

Replacement in pijul/src/remote/local.rs at line 90 [2.79745]

B:BD[2.82894] → [2.82894:82954]

            std::fs::hard_link(&local, &self.changes_dir)?;

[2.82894]

[2.82954]

            if std::fs::hard_link(&local, &self.changes_dir).is_err() {
                std::fs::copy(&local, &self.changes_dir)?;
            }

Deletion in pijul/src/remote/local.rs at line 96 [2.79745]
B:BD[2.83149] → [2.83149:83218]
```
            txn.apply_change_ws(&store, &mut channel, *c, &mut ws)?;
```

Replacement in pijul/src/remote/local.rs at line 98 [2.79745]

B:BD[2.83322] → [2.83322:83408]

        txn.output_repository_no_pending(&mut repo, &store, &mut channel, "", true)?;

[2.83322]

[2.83408]

        upload_changes(&store, &mut repo, &mut txn, &mut channel, changes)?;

Replacement in pijul/src/remote/local.rs at line 110 [2.79745]

B:BD[2.83755] → [2.83755:83809]

        std::fs::hard_link(&self.changes_dir, path)?;

[2.83755]

[2.83809]

        if std::fs::hard_link(&self.changes_dir, path).is_err() {
            std::fs::copy(&self.changes_dir, path)?;
        }

Insertion in pijul/src/remote/local.rs at line 119 [2.79745]

[2.83970]


pub fn upload_changes<
    T: MutTxnTExt,
    C: libpijul::changestore::ChangeStore,
    W: libpijul::working_copy::WorkingCopy,
>(
    store: &C,
    repo: &mut W,
    txn: &mut T,
    channel: &mut libpijul::pristine::ChannelRef<T>,
    changes: &[Hash],
) -> Result<(), anyhow::Error> {
    let mut ws = libpijul::ApplyWorkspace::new();
    for c in changes {
        txn.apply_change_ws(store, channel, *c, &mut ws)?;
    }
    txn.output_repository_no_pending(repo, store, channel, "", true)?;
    Ok(())
}

Replacement in pijul/src/commands/pushpull.rs at line 102 [2.111631]

B:BD[2.114511] → [2.114511:114570]

        let repo = Repository::find_root(self.repo_path)?;

[2.114511]

[2.114570]

        let mut repo = Repository::find_root(self.repo_path)?;

Replacement in pijul/src/commands/pushpull.rs at line 127 [2.111631]

B:BD[2.115467] → [2.115467:115537]

            .remote(&remote_name, remote_channel, self.no_cert_check)

[2.115467]

[2.115537]

            .remote(
                Some(&repo.path),
                &remote_name,
                remote_channel,
                self.no_cert_check,
            )

Replacement in pijul/src/commands/pushpull.rs at line 155 [2.111631]

B:BD[2.116338] → [2.116338:116665]

            if txn.remote_has_state(&remote_changes, m) {
                break;
            }
            let h_int = txn.get_internal(h).unwrap();
            if !txn.remote_has_change(&remote_changes, h) {
                if let Some(ref p) = path {
                    if txn.get_touched_files(*p, Some(h_int)).is_some() {

[2.116338]

[2.116665]

            if let Some(ref remote_changes) = remote_changes {
                if txn.remote_has_state(remote_changes, m) {
                    break;
                }
                let h_int = txn.get_internal(h).unwrap();
                if !txn.remote_has_change(&remote_changes, h) {
                    if let Some(ref p) = path {
                        if txn.get_touched_files(*p, Some(h_int)).is_some() {
                            to_upload.push(h)
                        }
                    } else {

Replacement in pijul/src/commands/pushpull.rs at line 168 [2.111631]

B:BD[2.116729] → [2.116729:116792]

                } else {
                    to_upload.push(h)

[2.116729]

[2.116792]

                }
            } else if let crate::remote::RemoteRepo::LocalChannel(ref remote_channel) = remote {
                if let Some(channel) = txn.load_channel(remote_channel) {
                    let channel = channel.borrow();
                    let h_int = txn.get_internal(h).unwrap();
                    if txn.get_changeset(&channel.changes, h_int, None).is_none() {
                        if let Some(ref p) = path {
                            if txn.get_touched_files(*p, Some(h_int)).is_some() {
                                to_upload.push(h)
                            }
                        } else {
                            to_upload.push(h)
                        }
                    }

Replacement in pijul/src/commands/pushpull.rs at line 226 [2.111631]

B:BD[2.117334] → [2.117334:117414]

            .upload_changes(repo.changes_dir.clone(), push_channel, &to_upload)

[2.117334]

[2.117414]

            .upload_changes(
                &mut repo.working_copy,
                &mut txn,
                repo.changes_dir.clone(),
                push_channel,
                &to_upload,
            )

Replacement in pijul/src/commands/pushpull.rs at line 261 [2.111631]

B:BD[2.118313] → [2.118313:118381]

            .remote(&remote_name, from_channel, self.no_cert_check)

[2.118313]

[2.118381]

            .remote(
                Some(&repo.path),
                &remote_name,
                from_channel,
                self.no_cert_check,
            )

Replacement in pijul/src/commands/pushpull.rs at line 271 [2.111631]

B:BD[2.118489] → [2.118489:118578]

            let paths = if let Some(p) = self.path {
                vec![p.to_string()]

[2.118489]

[2.118578]

            let mut paths = if let Some(p) = self.path {
                vec![p]

Replacement in pijul/src/commands/pushpull.rs at line 279 [2.111631]

B:BD[2.118806] → [2.118806:119084]

            for (_, (h, m)) in txn.iter_remote(&remote_changes.borrow().remote, 0) {
                if txn.channel_has_state(&channel, m) {
                    break;
                } else if txn.get_revchanges(&channel, h).is_none() {
                    to_download.push(h)

[2.118806]

[2.119084]

            if let Some(ref remote_changes) = remote_changes {
                for (_, (h, m)) in txn.iter_remote(&remote_changes.borrow().remote, 0) {
                    if txn.channel_has_state(&channel, m) {
                        break;
                    } else if txn.get_revchanges(&channel, h).is_none() {
                        to_download.push(h)
                    }
                }
            } else if let crate::remote::RemoteRepo::LocalChannel(ref remote_channel) = remote {
                let path = if let Some(path) = paths.pop() {
                    let (p, ambiguous) = txn.follow_oldest_path(&repo.changes, &channel, &path)?;
                    if ambiguous {
                        return Err((crate::Error::AmbiguousPath { path: path.clone() }).into());
                    }
                    Some(p)
                } else {
                    None
                };
                if let Some(remote_channel) = txn.load_channel(remote_channel) {
                    let remote_channel = remote_channel.borrow();
                    for (_, (h, m)) in txn.reverse_log(&remote_channel, None) {
                        if txn.channel_has_state(&channel, m) {
                            break;
                        }
                        let h_int = txn.get_internal(h).unwrap();
                        if txn
                            .get_changeset(&channel.borrow().changes, h_int, None)
                            .is_none()
                        {
                            if let Some(ref p) = path {
                                if txn.get_touched_files(*p, Some(h_int)).is_some() {
                                    to_download.push(h)
                                }
                            } else {
                                to_download.push(h)
                            }
                        }
                    }

Replacement in pijul/src/commands/clone.rs at line 31 [2.182891]

B:BD[2.183896] → [2.183896:183995]

            crate::remote::unknown_remote(&self.remote, &self.channel, self.no_cert_check).await?;

[2.183896]

[2.183995]

            crate::remote::unknown_remote(None, &self.remote, &self.channel, self.no_cert_check)
                .await?;

Replacement in pijul/src/commands/archive.rs at line 27 [2.191083]

B:BD[2.191803] → [2.191803:191861]

    pub async fn run(self) -> Result<(), anyhow::Error> {

[2.191803]

[2.191861]

    pub async fn run(mut self) -> Result<(), anyhow::Error> {

Insertion in pijul/src/commands/archive.rs at line 41 [2.191083]
[2.192281]
[2.192281]
```
                None,
```

Replacement in pijul/src/commands/archive.rs at line 51 [2.191083]

B:BD[2.192546] → [2.192546:192710]

            let mut p = std::path::Path::new(&self.name).to_path_buf();
            if !self.name.ends_with(".tar.gz") {
                p.set_extension("tar.gz");

[2.192546]

[2.192710]

            if let crate::remote::RemoteRepo::LocalChannel(_) = remote {
                if let Some(ref mut path) = self.repo_path {
                    path.clear();
                    path.push(rem);
                }
            } else {
                let mut p = std::path::Path::new(&self.name).to_path_buf();
                if !self.name.ends_with(".tar.gz") {
                    p.set_extension("tar.gz");
                }
                let mut f = std::fs::File::create(&p)?;
                remote
                    .archive(self.prefix, state.map(|x| (x, &extra[..])), &mut f)
                    .await?;
                return Ok(());

Replacement in pijul/src/commands/archive.rs at line 67 [2.191083]

B:BD[2.192724] → [2.192724:192979]

            let mut f = std::fs::File::create(&p)?;
            remote
                .archive(self.prefix, state.map(|x| (x, &extra[..])), &mut f)
                .await?;
        } else if let Ok(repo) = Repository::find_root(self.repo_path.clone()) {

[2.192724]

[2.192979]

        }
        if let Ok(repo) = Repository::find_root(self.repo_path.clone()) {

Pushing to, and pulling from the local repository

Dependencies

In channels

Change contents

Insertion in pijul/src/remote/mod.rs at line 18 [2.52474]

Insertion in pijul/src/remote/mod.rs at line 32 [2.52474]

Replacement in pijul/src/remote/mod.rs at line 38 [2.52474]

Replacement in pijul/src/remote/mod.rs at line 40 [2.52474]

Insertion in pijul/src/remote/mod.rs at line 46 [2.52474]

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