ilyagr/pijul - Change JL4WKA5PBKXRNAMETYO4I52QKASQ3COYHH2JKGA7W5YLIRZZH53AC

Implement the Sanakirja concurrency model in a cross-process way

Created by pmeunier on January 14, 2021

JL4WKA5PBKXRNAMETYO4I52QKASQ3COYHH2JKGA7W5YLIRZZH53AC

Dependencies

In channels

main

Change contents

Insertion in pijul/src/repository.rs at line 7 [9.21431]

[8.39]


#[cfg(not(unix))]
mod basic_lock;
#[cfg(unix)]
mod unix_lock;
mod lock {
    #[cfg(not(unix))]
    pub use super::basic_lock::*;
    #[cfg(unix)]
    pub use super::unix_lock::*;
    use std::path::Path;
    pub enum Lock {
        Txn(TxnLock),
        MutTxn(MutTxnLock),
    }

Insertion in pijul/src/repository.rs at line 24 [9.21431]

[8.40]

[10.7685]

    impl Lock {
        pub async fn mut_txn_lock<P: AsRef<Path>>(p: P) -> Result<Self, anyhow::Error> {
            let pp = p.as_ref().join("db_lock");
            Ok(Lock::MutTxn(mut_txn(&pp).await?))
        }
        pub async fn txn_lock<P: AsRef<Path>>(p: P) -> Result<Self, anyhow::Error> {
            let pp = p.as_ref().join("db_lock");
            Ok(Lock::Txn(txn(&pp).await?))
        }
        pub async fn commit(&mut self) -> Result<(), anyhow::Error> {
            match self {
                Lock::MutTxn(m) => m.commit().await,
                _ => Ok(()),
            }
        }
    }
}

Insertion in pijul/src/repository.rs at line 45 [9.21431]
[9.21565]
[9.21565]
```
    pub lock: lock::Lock,
```

Replacement in pijul/src/repository.rs at line 89 [9.21431]

B:BD[9.22907] → [9.22907:23034]

    pub fn find_root(cur: Option<PathBuf>) -> Result<Self, anyhow::Error> {
        Self::find_root_with_dot_dir(cur, DOT_DIR)

[9.22907]

[9.23034]

    pub async fn find_root(cur: Option<PathBuf>) -> Result<Self, anyhow::Error> {
        Self::find_root_with_dot_dir(cur, DOT_DIR, true).await

Replacement in pijul/src/repository.rs at line 93 [9.21431]

B:BD[9.23041] → [9.23041:23076]

    pub fn find_root_with_dot_dir(

[9.23041]

[9.23076]

    pub async unsafe fn find_root_immutable(cur: Option<PathBuf>) -> Result<Self, anyhow::Error> {
        Self::find_root_with_dot_dir(cur, DOT_DIR, false).await
    }
    pub async fn find_root_with_dot_dir(

Insertion in pijul/src/repository.rs at line 100 [9.21431]
[9.23129]
[9.23129]
```
        mutable: bool,
```

Replacement in pijul/src/repository.rs at line 120 [9.21431]

B:BD[9.23883] → [9.23883:23967]

            pristine: libpijul::pristine::sanakirja::Pristine::new(&pristine_dir)?,

[9.23883]

[9.23967]

            lock: if mutable {
                lock::Lock::mut_txn_lock(&pristine_dir).await?
            } else {
                lock::Lock::txn_lock(&pristine_dir).await?
            },
            pristine: unsafe {
                libpijul::pristine::sanakirja::Pristine::new_nolock(&pristine_dir)?
            },

Replacement in pijul/src/repository.rs at line 138 [9.21431]

B:BD[9.24299] → [9.24299:24382]

    pub fn init(path: Option<std::path::PathBuf>) -> Result<Self, anyhow::Error> {

[9.24299]

[9.24382]

    pub async fn init(path: Option<std::path::PathBuf>) -> Result<Self, anyhow::Error> {

Replacement in pijul/src/repository.rs at line 153 [9.21431]

B:BD[9.24885] → [9.24885:24973]

                pristine: libpijul::pristine::sanakirja::Pristine::new(&pristine_dir)?,

[9.24885]

[9.24973]

                lock: lock::Lock::mut_txn_lock(&pristine_dir).await?,
                pristine: unsafe {
                    libpijul::pristine::sanakirja::Pristine::new_nolock(&pristine_dir)?
                },

File addition: repository (drwxr-xr-x)
[9.21414]

File addition: unix_lock.rs (-rw-r--r--)

[0.1940]

use anyhow::bail;
use std::io::Read;
use std::path::Path;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::UnixStream;
pub struct TxnLock {
    _stream: UnixStream,
}
pub struct MutTxnLock {
    stream: UnixStream,
}
const TXN_BEGIN: u8 = 0;
const MUT_TXN_BEGIN: u8 = 1;
const COMMIT: u8 = 2;
const ACK: u8 = 3;
pub async fn mut_txn<P: AsRef<Path>>(file: P) -> Result<MutTxnLock, anyhow::Error> {
    let cmd = std::env::args().next().unwrap();
    let mut process = std::process::Command::new(&cmd)
        .args(&["lock", file.as_ref().to_str().unwrap()])
        .stdout(std::process::Stdio::piped())
        .spawn()?;
    let s = process.stdout.as_mut().unwrap();
    s.read(&mut [0u8])?;
    let mut stream = UnixStream::connect(file).await?;
    stream.writable().await?;
    stream.write_all(&[MUT_TXN_BEGIN]).await?;
    let mut t = [0u8];
    stream.read_exact(&mut t).await?;
    if t[0] == ACK {
        Ok(MutTxnLock { stream })
    } else {
        bail!("Pristine locked")
    }
}
pub async fn txn<P: AsRef<Path>>(file: P) -> Result<TxnLock, anyhow::Error> {
    let cmd = std::env::args().next().unwrap();
    std::process::Command::new(&cmd)
        .args(&["lock", file.as_ref().to_str().unwrap()])
        .spawn()?;
    let mut stream = UnixStream::connect(file).await?;
    stream.write_all(&[TXN_BEGIN]).await?;
    let mut t = [0u8];
    stream.read_exact(&mut t).await?;
    if t[0] == ACK {
        Ok(TxnLock { _stream: stream })
    } else {
        bail!("Pristine locked")
    }
}
impl MutTxnLock {
    pub async fn commit(&mut self) -> Result<(), anyhow::Error> {
        self.stream.write_all(&[COMMIT]).await?;
        Ok(())
    }
}

File addition: basic_lock.rs (-rw-r--r--)

[0.1940]

use fs2::FileExt;
use std::fs::OpenOptions;
use std::path::Path;
pub struct TxnLock {
    file: std::fs::File,
}
pub struct MutTxnLock {
    file: std::fs::File,
}
pub async fn mut_txn<P: AsRef<Path>>(file: P) -> Result<MutTxnLock, anyhow::Error> {
    let file = OpenOptions::new().write(true).create(true).open(file)?;
    file.lock_exclusive()?;
    Ok(MutTxnLock { file })
}
pub async fn txn<P: AsRef<Path>>(file: P) -> Result<TxnLock, anyhow::Error> {
    let file = OpenOptions::new().write(true).create(true).open(file)?;
    file.lock_shared()?;
    Ok(TxnLock { file })
}
impl MutTxnLock {
    pub async fn commit(&mut self) -> Result<(), anyhow::Error> {
        Ok(self.file.unlock()?)
    }
}
impl Drop for MutTxnLock {
    fn drop(&mut self) {
        self.file.unlock().unwrap_or(())
    }
}
impl Drop for TxnLock {
    fn drop(&mut self) {
        self.file.unlock().unwrap_or(())
    }
}

Insertion in pijul/src/main.rs at line 122 [9.83981]
[9.85778]
[11.25]
```
    #[cfg(unix)]
    Lock(Lock),
```

Replacement in pijul/src/main.rs at line 187 [9.83981]

B:BD[9.88438] → [9.88438:88523]

        SubCommand::Log(l) => l.run(),
        SubCommand::Init(init) => init.run(),

[9.88438]

[9.88523]

        SubCommand::Log(l) => l.run().await,
        SubCommand::Init(init) => init.run().await,

Replacement in pijul/src/main.rs at line 191 [9.83981]

B:BD[9.88636] → [9.88636:88682]

        SubCommand::Diff(diff) => diff.run(),

[9.88636]

[9.88682]

        SubCommand::Diff(diff) => diff.run().await,

Replacement in pijul/src/main.rs at line 194 [9.83981]

B:BD[9.88786] → [9.88786:88951]

        SubCommand::Change(change) => change.run(),
        SubCommand::Channel(channel) => channel.run(),
        SubCommand::Protocol(protocol) => protocol.run(),

[9.88786]

[9.88951]

        SubCommand::Change(change) => change.run().await,
        SubCommand::Channel(channel) => channel.run().await,
        SubCommand::Protocol(protocol) => protocol.run().await,

Replacement in pijul/src/main.rs at line 198 [9.83981]

B:BD[9.88983] → [9.88983:89250]

        SubCommand::Git(git) => git.run(),
        SubCommand::Mv(mv) => mv.run(),
        SubCommand::Ls(ls) => ls.run(),
        SubCommand::Add(add) => add.run(),
        SubCommand::Remove(remove) => remove.run(),
        SubCommand::Reset(reset) => reset.run(),

[9.88983]

[9.89250]

        SubCommand::Git(git) => git.run().await,
        SubCommand::Mv(mv) => mv.run().await,
        SubCommand::Ls(ls) => ls.run().await,
        SubCommand::Add(add) => add.run().await,
        SubCommand::Remove(remove) => remove.run().await,
        SubCommand::Reset(reset) => reset.run().await,

Replacement in pijul/src/main.rs at line 205 [9.83981]

B:BD[9.89283] → [9.89283:89537]

        SubCommand::Debug(debug) => debug.run(),
        SubCommand::Fork(fork) => fork.run(),
        SubCommand::Unrecord(unrecord) => unrecord.run(),
        SubCommand::Apply(apply) => apply.run(),
        SubCommand::Remote(remote) => remote.run(),

[9.89283]

[9.89537]

        SubCommand::Debug(debug) => debug.run().await,
        SubCommand::Fork(fork) => fork.run().await,
        SubCommand::Unrecord(unrecord) => unrecord.run().await,
        SubCommand::Apply(apply) => apply.run().await,
        SubCommand::Remote(remote) => remote.run().await,

Replacement in pijul/src/main.rs at line 211 [9.83981]

B:BD[9.89598] → [9.89598:89650]

        SubCommand::Credit(credit) => credit.run(),

[9.89598]

[11.600]

        SubCommand::Credit(credit) => credit.run().await,
        #[cfg(unix)]
        SubCommand::Lock(lock) => lock.run().await,

Replacement in pijul/src/commands/unrecord.rs at line 35 [9.95630]

B:BD[9.96125] → [9.96125:96177]

B:BD[9.96177] → [12.250:313]

    pub fn run(self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::find_root(self.repo_path)?;

[9.96125]

[9.96236]

    pub async fn run(self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::find_root(self.repo_path).await?;

Insertion in pijul/src/commands/unrecord.rs at line 137 [9.95630]
[9.97615]
[9.97615]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/reset.rs at line 29 [9.97650]

B:BD[9.98112] → [9.98112:98164]

B:BD[9.98164] → [13.447:472]

    pub fn run(self) -> Result<(), anyhow::Error> {
        self.reset(true)

[9.98112]

[13.472]

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

Replacement in pijul/src/commands/reset.rs at line 33 [9.97650]

B:BD[13.479] → [13.479:560]

    pub fn switch(self) -> Result<(), anyhow::Error> {
        self.reset(false)

[13.479]

[13.560]

    pub async fn switch(self) -> Result<(), anyhow::Error> {
        self.reset(false).await

Replacement in pijul/src/commands/reset.rs at line 37 [9.97650]

B:BD[13.567] → [13.567:642]

    fn reset(self, overwrite_changes: bool) -> Result<(), anyhow::Error> {

[13.567]

[9.98164]

    async fn reset(self, overwrite_changes: bool) -> Result<(), anyhow::Error> {

Replacement in pijul/src/commands/reset.rs at line 39 [9.97650]

B:BD[9.98218] → [9.98218:98281]

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

[9.98218]

[9.98281]

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

Insertion in pijul/src/commands/reset.rs at line 109 [9.97650]
[14.773]
[14.773]
```
                    repo.lock.commit().await?;
```
Insertion in pijul/src/commands/reset.rs at line 166 [9.97650]
[15.6587]
[15.6587]
```
            repo.lock.commit().await?;
```

Replacement in pijul/src/commands/record.rs at line 59 [9.101759]

B:BD[9.102832] → [9.102832:102903]

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

[9.102832]

[9.102903]

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

Insertion in pijul/src/commands/record.rs at line 156 [9.101759]
[9.105279]
[9.105279]
```
            repo.lock.commit().await?;
```
Insertion in pijul/src/commands/record.rs at line 162 [9.101759]
[16.301]
[5.57]
```
                repo.lock.commit().await?;
```

Replacement in pijul/src/commands/pushpull.rs at line 33 [9.111631]

B:BD[9.112203] → [9.112203:112314]

    pub fn run(self) -> Result<(), anyhow::Error> {
        let repo = Repository::find_root(self.repo_path)?;

[9.112203]

[9.112314]

    pub async fn run(self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::find_root(self.repo_path).await?;

Insertion in pijul/src/commands/pushpull.rs at line 51 [9.111631]
[9.112970]
[9.112970]
```
                    repo.lock.commit().await?;
```
Replacement in pijul/src/commands/pushpull.rs at line 123 [9.111631]
∅:D[17.1981] → [18.153:212]
B:BD[9.114511] → [18.153:212]
```
        let repo = Repository::find_root(self.repo_path)?;
```
[17.1981]
[9.114570]
```
        let mut repo = Repository::find_root(self.repo_path).await?;
```
Insertion in pijul/src/commands/pushpull.rs at line 268 [9.111631]
[9.117458]
[9.117458]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/pushpull.rs at line 277 [9.111631]

B:BD[9.117585] → [9.117585:117648]

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

[9.117585]

[9.117648]

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

Insertion in pijul/src/commands/pushpull.rs at line 476 [9.111631]
[9.121124]
[9.121124]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/protocol.rs at line 49 [9.123281]

B:BD[9.124762] → [9.124762:124877]

    pub fn run(self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::find_root(self.repo_path)?;

[9.124762]

[9.124877]

    pub async fn run(self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::find_root(self.repo_path).await?;

Insertion in pijul/src/commands/protocol.rs at line 250 [9.123281]
[9.133576]
[9.133576]
```
            repo.lock.commit().await?;
```
Insertion in pijul/src/commands/mod.rs at line 59 [9.133619]
[9.134333]
[12.1576]
```
#[cfg(unix)]
mod lock;
#[cfg(unix)]
pub use lock::*;
```

Replacement in pijul/src/commands/log.rs at line 31 [9.134376]

B:BD[9.134895] → [9.134895:135006]

    pub fn run(self) -> Result<(), anyhow::Error> {
        let repo = Repository::find_root(self.repo_path)?;

[9.134895]

[9.135006]

    pub async fn run(self) -> Result<(), anyhow::Error> {
        let repo = unsafe { Repository::find_root_immutable(self.repo_path).await? };

File addition: lock.rs (-rw-r--r--)

[9.93386]

use fs2::FileExt;
use std::fs::OpenOptions;
use std::io::Write;
use std::path::PathBuf;
use std::sync::Arc;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::UnixListener;
use tokio::sync::{watch, Mutex};
use clap::Clap;
#[derive(Clap, Debug)]
pub struct Lock {
    path: PathBuf,
}
const COMMIT: u8 = 2;
const ACK: u8 = 3;
const LOCKED: u8 = 4;
impl Lock {
    pub async fn run(self) -> Result<(), anyhow::Error> {
        let lock = Arc::new(self.path.with_extension("lock"));
        let lockfile = OpenOptions::new()
            .write(true)
            .create(true)
            .open(&lock.as_ref())
            .unwrap();
        if lockfile.try_lock_exclusive().is_err() {
            return Ok(());
        }
        let listener = UnixListener::bind(&self.path).unwrap();
        println!();
        let n_clients = Arc::new(Mutex::new(0usize));
        let file = Arc::new(self.path.clone());
        let muttxn = Arc::new(Mutex::new(()));
        let (tx, active_at_last_commit) = watch::channel(0);
        let tx = std::sync::Arc::new(tx);
        let clock = Arc::new(Mutex::new(0usize));
        let txn_counter = Arc::new(Mutex::new(0usize));
        let last_commit_date = Arc::new(Mutex::new(0usize));
        loop {
            let x = listener.accept().await;
            {
                let mut f = OpenOptions::new()
                    .write(true)
                    .create(true)
                    .append(true)
                    .open("log")
                    .unwrap();
                writeln!(f, "accepted").unwrap()
            }
            match x {
                Ok((mut stream, _addr)) => {
                    *n_clients.lock().await += 1;
                    {
                        let mut f = OpenOptions::new()
                            .write(true)
                            .create(true)
                            .append(true)
                            .open("log")
                            .unwrap();
                        writeln!(f, "n = {:?}", *n_clients.lock().await).unwrap();
                    }
                    let file = file.clone();
                    let muttxn = muttxn.clone();
                    let mut active_at_last_commit = active_at_last_commit.clone();
                    let clock = clock.clone();
                    let last_commit_date = last_commit_date.clone();
                    let txn_counter = txn_counter.clone();
                    let n_clients = n_clients.clone();
                    let tx = tx.clone();
                    let lock = lock.clone();
                    tokio::spawn(async move {
                        let mut t = [0u8];
                        while let Ok(n) = stream.read(&mut t).await {
                            if n == 0 {
                                break;
                            }
                            if t[0] == 1 {
                                // muttxn
                                let lock = if let Ok(guard) = muttxn.try_lock() {
                                    guard
                                } else {
                                    stream.write_all(&[LOCKED]).await.unwrap_or(());
                                    muttxn.lock().await
                                };
                                while *active_at_last_commit.borrow() > 0 {
                                    stream.write_all(&[LOCKED]).await.unwrap_or(());
                                    active_at_last_commit.changed().await.unwrap();
                                }
                                stream.write_all(&[ACK]).await.unwrap_or(());
                                if let Ok(n) = stream.read(&mut t).await {
                                    if n == 0 {
                                        break;
                                    }
                                    if t[0] == COMMIT {
                                        // commit
                                        let mut clock = clock.lock().await;
                                        *clock += 1;
                                        *last_commit_date.lock().await = *clock;
                                        let counter = *txn_counter.lock().await;
                                        tx.send(counter).unwrap();
                                    }
                                }
                                std::mem::drop(lock);
                            } else {
                                // txn
                                *txn_counter.lock().await += 1;
                                let start_date = *clock.lock().await;
                                stream.write_all(&[ACK]).await.unwrap_or(());
                                let n = stream.read(&mut t).await.unwrap_or(0);
                                if n == 0 {
                                    break;
                                }
                                *txn_counter.lock().await -= 1;
                                if start_date < *last_commit_date.lock().await {
                                    let last = *active_at_last_commit.borrow();
                                    tx.send(last - 1).unwrap();
                                }
                            }
                        }
                        {
                            let mut f = OpenOptions::new()
                                .write(true)
                                .create(true)
                                .append(true)
                                .open("log")
                                .unwrap();
                            writeln!(f, "n = {:?}", *n_clients.lock().await).unwrap();
                        }
                        if *n_clients.lock().await == 1 {
                            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
                            if *n_clients.lock().await == 1 {
                                std::fs::remove_file(file.as_ref()).unwrap_or(());
                                let lockfile = OpenOptions::new()
                                    .write(true)
                                    .create(true)
                                    .open(lock.as_ref())
                                    .unwrap();
                                lockfile.unlock().unwrap_or(());
                                std::process::exit(0)
                            }
                        }
                        *n_clients.lock().await -= 1
                    });
                }
                Err(_) => break,
            }
        }
        std::fs::remove_file(file.as_ref()).unwrap_or(());
        let lockfile = OpenOptions::new()
            .write(true)
            .create(true)
            .open(lock.as_ref())
            .unwrap();
        lockfile.unlock().unwrap_or(());
        std::process::exit(0)
    }
}

Replacement in pijul/src/commands/init.rs at line 18 [9.136543]

B:BD[9.136770] → [9.136770:136875]

    pub fn run(self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::init(self.path)?;

[9.136770]

[9.136875]

    pub async fn run(self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::init(self.path).await?;

Insertion in pijul/src/commands/init.rs at line 28 [9.136543]
[9.137177]
[9.137177]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/git.rs at line 37 [9.137210]

B:BD[9.138045] → [9.138045:138182]

    pub fn run(self) -> Result<(), anyhow::Error> {
        let repo = if let Ok(repo) = Repository::find_root(self.repo_path.clone()) {

[9.138045]

[9.138182]

    pub async fn run(self) -> Result<(), anyhow::Error> {
        let repo = if let Ok(repo) = Repository::find_root(self.repo_path.clone()).await {

Replacement in pijul/src/commands/git.rs at line 41 [9.137210]

B:BD[9.138216] → [9.138216:138270]

            Repository::init(self.repo_path.clone())?

[9.138216]

[9.138270]

            Repository::init(self.repo_path.clone()).await?

Replacement in pijul/src/commands/git.rs at line 65 [9.137210]

B:BD[9.139131] → [9.139131:139185]

        import(&git, &mut env_git, &mut repo, &dag)?;

[9.139131]

[9.139185]

        import(&git, &mut env_git, &mut repo, &dag).await?;

Replacement in pijul/src/commands/git.rs at line 219 [9.137210]
B:BD[9.143830] → [9.143830:143841]
```
fn import(
```
[9.143830]
[9.143841]
```
async fn import(
```
Insertion in pijul/src/commands/git.rs at line 312 [9.137210]
[9.147539]
[9.147539]
```
            repo.repo.lock.commit().await?;
```

Replacement in pijul/src/commands/fork.rs at line 25 [9.167873]

B:BD[9.168309] → [9.168309:168420]

    pub fn run(self) -> Result<(), anyhow::Error> {
        let repo = Repository::find_root(self.repo_path)?;

[9.168309]

[9.168420]

    pub async fn run(self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::find_root(self.repo_path).await?;

Insertion in pijul/src/commands/fork.rs at line 40 [9.167873]
[9.169013]
[9.169013]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/file_operations.rs at line 24 [9.169058]

B:BD[9.169351] → [9.169351:169474]

    pub fn run(mut self) -> Result<(), anyhow::Error> {
        let repo = Repository::find_root(self.repo_path.clone())?;

[9.169351]

[9.169474]

    pub async fn run(mut self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::find_root(self.repo_path.clone()).await?;

Insertion in pijul/src/commands/file_operations.rs at line 57 [9.169058]
[9.170571]
[9.170571]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/file_operations.rs at line 78 [9.169058]

B:BD[9.170860] → [9.170860:170912]

B:BD[9.170912] → [19.394:453]

    pub fn run(self) -> Result<(), anyhow::Error> {
        let repo = Repository::find_root(self.repo_path)?;

[9.170860]

[9.170979]

    pub async fn run(self) -> Result<(), anyhow::Error> {
        let repo = unsafe { Repository::find_root_immutable(self.repo_path).await? };

Replacement in pijul/src/commands/file_operations.rs at line 104 [9.169058]

B:BD[9.171335] → [9.171335:171454]

    pub fn run(self) -> Result<(), anyhow::Error> {
        let repo = Repository::find_root(self.repo_path.clone())?;

[9.171335]

[9.171454]

    pub async fn run(self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::find_root(self.repo_path.clone()).await?;

Insertion in pijul/src/commands/file_operations.rs at line 151 [9.169058]
[9.172439]
[9.172439]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/file_operations.rs at line 166 [9.169058]

B:BD[9.172614] → [9.172614:172733]

    pub fn run(self) -> Result<(), anyhow::Error> {
        let repo = Repository::find_root(self.repo_path.clone())?;

[9.172614]

[9.172733]

    pub async fn run(self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::find_root(self.repo_path.clone()).await?;

Insertion in pijul/src/commands/file_operations.rs at line 193 [9.169058]
[9.173517]
[9.173517]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/diff.rs at line 35 [9.173551]

B:BD[9.174051] → [9.174051:174178]

    pub fn run(mut self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::find_root(self.repo_path.clone())?;

[9.174051]

[9.174178]

    pub async fn run(mut self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::find_root(self.repo_path.clone()).await?;

Replacement in pijul/src/commands/debug.rs at line 18 [9.177758]

B:BD[9.178019] → [9.178019:178130]

    pub fn run(self) -> Result<(), anyhow::Error> {
        let repo = Repository::find_root(self.repo_path)?;

[9.178019]

[9.178130]

    pub async fn run(self) -> Result<(), anyhow::Error> {
        let repo = Repository::find_root(self.repo_path).await?;

Replacement in pijul/src/commands/credit.rs at line 26 [9.178684]
B:BD[9.179133] → [9.179133:179185]
```
    pub fn run(self) -> Result<(), anyhow::Error> {
```
[9.179133]
[9.179185]
```
    pub async fn run(self) -> Result<(), anyhow::Error> {
```

Replacement in pijul/src/commands/credit.rs at line 28 [9.178684]

B:BD[9.179239] → [9.179239:179302]

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

[9.179239]

[9.179302]

        let mut repo = unsafe { Repository::find_root_immutable(self.repo_path).await? };

Replacement in pijul/src/commands/clone.rs at line 68 [9.182891]

B:BD[20.167] → [4.221:275]

        let mut repo = Repository::init(Some(path))?;

[20.167]

[9.184784]

        let mut repo = Repository::init(Some(path)).await?;

Insertion in pijul/src/commands/clone.rs at line 108 [9.182891]
[9.185801]
[21.2373]
```
        repo.lock.commit().await?;
```
Replacement in pijul/src/commands/channel.rs at line 35 [9.186892]
B:BD[9.187383] → [9.187383:187435]
```
    pub fn run(self) -> Result<(), anyhow::Error> {
```
[9.187383]
[9.187494]
```
    pub async fn run(self) -> Result<(), anyhow::Error> {
```

Replacement in pijul/src/commands/channel.rs at line 39 [9.186892]

B:BD[9.187735] → [13.1000:1067]

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

[9.187735]

[13.1067]

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

Replacement in pijul/src/commands/channel.rs at line 54 [9.186892]

B:BD[9.188244] → [13.1129:1196]

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

[9.188244]

[13.1196]

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

Insertion in pijul/src/commands/channel.rs at line 64 [9.186892]
[9.188379]
[9.188379]
```
                repo.lock.commit().await?;
```

Replacement in pijul/src/commands/channel.rs at line 73 [9.186892]

B:BD[22.6398] → [22.6398:6426]

                .switch()?;

[22.6398]

[13.1727]

                .switch()
                .await?;

Replacement in pijul/src/commands/channel.rs at line 77 [9.186892]

B:BD[9.188456] → [13.1742:1809]

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

[9.188456]

[13.1809]

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

Insertion in pijul/src/commands/channel.rs at line 94 [9.186892]
[9.189246]
[9.189246]
```
                repo.lock.commit().await?;
```

Replacement in pijul/src/commands/change.rs at line 21 [9.189306]

B:BD[9.189681] → [9.189681:189800]

    pub fn run(self) -> Result<(), anyhow::Error> {
        let repo = Repository::find_root(self.repo_path.clone())?;

[9.189681]

[9.189800]

    pub async fn run(self) -> Result<(), anyhow::Error> {
        let repo = unsafe { Repository::find_root_immutable(self.repo_path.clone()).await? };

Replacement in pijul/src/commands/archive.rs at line 85 [9.191083]

B:BD[23.8987] → [23.8987:9061]

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

[23.8987]

[9.192979]

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

Replacement in pijul/src/commands/apply.rs at line 27 [9.194289]

B:BD[9.194761] → [9.194761:194876]

    pub fn run(self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::find_root(self.repo_path)?;

[9.194761]

[9.194876]

    pub async fn run(self) -> Result<(), anyhow::Error> {
        let mut repo = Repository::find_root(self.repo_path).await?;

Insertion in pijul/src/commands/apply.rs at line 91 [9.194289]
[9.196337]
[9.196337]
```
        repo.lock.commit().await?;
```
Replacement in pijul/Cargo.toml at line 4 [9.196374]
B:BD[9.196462] → [6.0:27]
```
version = "1.0.0-alpha.32"
```
[9.196462]
[9.196488]
```
version = "1.0.0-alpha.33"
```
Insertion in pijul/Cargo.toml at line 32 [9.196374]
[9.197171]
[9.197171]
```
"src/commands/lock.rs",
```
Insertion in pijul/Cargo.toml at line 35 [9.196374]
[9.197209]
[9.197209]
```
"src/repository/unix_lock.rs",
"src/repository/basic_lock.rs",
```

Replacement in pijul/Cargo.toml at line 53 [9.196374]

B:BD[9.197438] → [6.28:118]

libpijul = { path = "../libpijul", version = "1.0.0-alpha.29", features = [ "tarball" ] }

[9.197438]

[9.197523]

libpijul = { path = "../libpijul", version = "1.0.0-alpha.30", features = [ "tarball" ] }

Insertion in pijul/Cargo.toml at line 87 [9.196374]
[3.2300]
[24.309]
```
fs2 = "0.4"
```
Replacement in libpijul/Cargo.toml at line 4 [9.1020742]
B:BD[9.1020894] → [7.0:27]
```
version = "1.0.0-alpha.29"
```
[9.1020894]
[7.27]
```
version = "1.0.0-alpha.30"
```
Replacement in Cargo.lock at line 519 [9.1030385]
B:BD[9.1044908] → [2.465:483]
```
version = "0.3.9"
```
[9.1044908]
[9.1044926]
```
version = "0.3.10"
```

Replacement in Cargo.lock at line 521 [9.1030385]

B:BD[9.1044991] → [2.484:562]

checksum = "c70be434c505aee38639abccb918163b63158a4b4bb791b45b7023044bdc3c9c"

[9.1044991]

[9.1045069]

checksum = "309f13e3f4be6d5917178c84db67c0b9a09177ac16d4f9a7313a767a68adaa77"

Replacement in Cargo.lock at line 534 [9.1030385]
B:BD[9.1045250] → [2.563:581]
```
version = "0.3.9"
```
[9.1045250]
[9.1045268]
```
version = "0.3.10"
```

Replacement in Cargo.lock at line 536 [9.1030385]

B:BD[9.1045333] → [2.582:660]

checksum = "f01c61843314e95f96cc9245702248733a3a3d744e43e2e755e3c7af8348a0a9"

[9.1045333]

[9.1045411]

checksum = "7a3b03bd32f6ec7885edeb99acd1e47e20e34fd4dfd3c6deed6fcac8a9d28f6a"

Replacement in Cargo.lock at line 544 [9.1030385]
B:BD[9.1045499] → [2.661:679]
```
version = "0.3.9"
```
[9.1045499]
[9.1045517]
```
version = "0.3.10"
```

Replacement in Cargo.lock at line 546 [9.1030385]

B:BD[9.1045582] → [2.680:758]

checksum = "db8d3b0917ff63a2a96173133c02818fac4a746b0a57569d3baca9ec0e945e08"

[9.1045582]

[9.1045660]

checksum = "ed8aeae2b6ab243ebabe6f54cd4cf53054d98883d5d326128af7d57a9ca5cd3d"

Replacement in Cargo.lock at line 550 [9.1030385]
B:BD[9.1045699] → [2.759:777]
```
version = "0.3.9"
```
[9.1045699]
[9.1045717]
```
version = "0.3.10"
```

Replacement in Cargo.lock at line 552 [9.1030385]

B:BD[9.1045782] → [2.778:856]

checksum = "9ee9ca2f7eb4475772cf39dd1cd06208dce2670ad38f4d9c7262b3e15f127068"

[9.1045782]

[9.1045860]

checksum = "3f7836b36b7533d16fd5937311d98ba8965ab81030de8b0024c299dd5d51fb9b"

Replacement in Cargo.lock at line 561 [9.1030385]
B:BD[9.1045963] → [2.857:875]
```
version = "0.3.9"
```
[9.1045963]
[9.1045981]
```
version = "0.3.10"
```

Replacement in Cargo.lock at line 563 [9.1030385]

B:BD[9.1046046] → [2.876:954]

checksum = "e37c1a51b037b80922864b8eed90692c5cd8abd4c71ce49b77146caa47f3253b"

[9.1046046]

[9.1046124]

checksum = "d41234e71d5e8ca73d01563974ef6f50e516d71e18f1a2f1184742e31f5d469f"

Replacement in Cargo.lock at line 567 [9.1030385]
B:BD[9.1046160] → [2.955:973]
```
version = "0.3.9"
```
[9.1046160]
[9.1046178]
```
version = "0.3.10"
```

Replacement in Cargo.lock at line 569 [9.1030385]

B:BD[9.1046243] → [2.974:1052]

checksum = "0f8719ca0e1f3c5e34f3efe4570ef2c0610ca6da85ae7990d472e9cbfba13664"

[9.1046243]

[9.1046321]

checksum = "3520e0eb4e704e88d771b92d51273ee212997f0d8282f17f5d8ff1cb39104e42"

Replacement in Cargo.lock at line 579 [9.1030385]
B:BD[9.1046429] → [2.1053:1071]
```
version = "0.3.9"
```
[9.1046429]
[9.1046447]
```
version = "0.3.10"
```

Replacement in Cargo.lock at line 581 [9.1030385]

B:BD[9.1046512] → [2.1072:1150]

checksum = "f6adabac1290109cfa089f79192fb6244ad2c3f1cc2281f3e1dd987592b71feb"

[9.1046512]

[9.1046590]

checksum = "c72d188479368953c6c8c7140e40d7a4401674ab3b98a41e60e515d6cbdbe5de"

Replacement in Cargo.lock at line 585 [9.1030385]
B:BD[9.1046625] → [2.1151:1169]
```
version = "0.3.9"
```
[9.1046625]
[9.1046643]
```
version = "0.3.10"
```

Replacement in Cargo.lock at line 587 [9.1030385]

B:BD[9.1046708] → [2.1170:1248]

checksum = "a92a0843a2ff66823a8f7c77bffe9a09be2b64e533562c412d63075643ec0038"

[9.1046708]

[9.1046786]

checksum = "08944cea9021170d383287169859c0ca8147d9ec285978393109954448f33cc7"

Replacement in Cargo.lock at line 594 [9.1030385]
B:BD[9.1046854] → [2.1249:1267]
```
version = "0.3.9"
```
[9.1046854]
[9.1046872]
```
version = "0.3.10"
```

Replacement in Cargo.lock at line 596 [9.1030385]

B:BD[9.1046937] → [2.1268:1346]

checksum = "036a2107cdeb57f6d7322f1b6c363dad67cd63ca3b7d1b925bdf75bd5d96cda9"

[9.1046937]

[9.1047015]

checksum = "d3dd206efbe2ca683b2ce138ccdf61e1b0a63f5816dcedc9d8654c500ba0cea6"

Replacement in Cargo.lock at line 778 [9.1030385]
B:BD[9.1051116] → [9.1051116:1051134]
```
version = "2.0.1"
```
[9.1050888]
[9.1051134]
```
version = "2.1.0"
```

Replacement in Cargo.lock at line 780 [9.1030385]

B:BD[9.1051199] → [9.1051199:1051277]

checksum = "3c1ad908cc71012b7bea4d0c53ba96a8cba9962f048fa68d143376143d863b7a"

[9.1051199]

[9.1051277]

checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"

Replacement in Cargo.lock at line 937 [9.1030385]
B:BD[25.560] → [6.2003:2030]
```
version = "1.0.0-alpha.29"
```
[25.560]
[25.729]
```
version = "1.0.0-alpha.30"
```
Replacement in Cargo.lock at line 1288 [9.1030385]
B:BD[9.1064071] → [6.2031:2058]
```
version = "1.0.0-alpha.32"
```
[9.1064071]
[9.1064097]
```
version = "1.0.0-alpha.33"
```
Insertion in Cargo.lock at line 1301 [9.1030385]
[26.5827]
[9.1064248]
```
 "fs2",
```
Replacement in Cargo.lock at line 1437 [9.1030385]
B:BD[9.1067251] → [9.1067251:1067269]
```
version = "0.1.6"
```
[9.1067251]
[9.1067269]
```
version = "0.1.7"
```

Replacement in Cargo.lock at line 1439 [9.1030385]

B:BD[9.1067334] → [9.1067334:1067412]

checksum = "eba180dafb9038b050a4c280019bbedf9f2467b61e5d892dcad585bb57aadc5a"

[9.1067334]

[9.1067412]

checksum = "bc881b2c22681370c6a780e47af9840ef841837bc98118431d4e1868bd0c1086"

Implement the Sanakirja concurrency model in a cross-process way

Dependencies

In channels

Change contents

Insertion in pijul/src/repository.rs at line 7 [9.21431]

Insertion in pijul/src/repository.rs at line 24 [9.21431]

Insertion in pijul/src/repository.rs at line 45 [9.21431]

Replacement in pijul/src/repository.rs at line 89 [9.21431]

Replacement in pijul/src/repository.rs at line 93 [9.21431]

Insertion in pijul/src/repository.rs at line 100 [9.21431]

Replacement in pijul/src/repository.rs at line 120 [9.21431]

Replacement in pijul/src/repository.rs at line 138 [9.21431]

Replacement in pijul/src/repository.rs at line 153 [9.21431]

File addition: repository (drwxr-xr-x)

File addition: unix_lock.rs (-rw-r--r--)

File addition: basic_lock.rs (-rw-r--r--)

Insertion in pijul/src/main.rs at line 122 [9.83981]

Replacement in pijul/src/main.rs at line 187 [9.83981]

Replacement in pijul/src/main.rs at line 191 [9.83981]

Replacement in pijul/src/main.rs at line 194 [9.83981]

Replacement in pijul/src/main.rs at line 198 [9.83981]

Replacement in pijul/src/main.rs at line 205 [9.83981]

Replacement in pijul/src/main.rs at line 211 [9.83981]

Replacement in pijul/src/commands/unrecord.rs at line 35 [9.95630]

Insertion in pijul/src/commands/unrecord.rs at line 137 [9.95630]

Replacement in pijul/src/commands/reset.rs at line 29 [9.97650]

Replacement in pijul/src/commands/reset.rs at line 33 [9.97650]

Replacement in pijul/src/commands/reset.rs at line 37 [9.97650]

Replacement in pijul/src/commands/reset.rs at line 39 [9.97650]

Insertion in pijul/src/commands/reset.rs at line 109 [9.97650]

Insertion in pijul/src/commands/reset.rs at line 166 [9.97650]

Replacement in pijul/src/commands/record.rs at line 59 [9.101759]

Insertion in pijul/src/commands/record.rs at line 156 [9.101759]

Insertion in pijul/src/commands/record.rs at line 162 [9.101759]

Replacement in pijul/src/commands/pushpull.rs at line 33 [9.111631]

Insertion in pijul/src/commands/pushpull.rs at line 51 [9.111631]

Replacement in pijul/src/commands/pushpull.rs at line 123 [9.111631]

Insertion in pijul/src/commands/pushpull.rs at line 268 [9.111631]

Replacement in pijul/src/commands/pushpull.rs at line 277 [9.111631]

Insertion in pijul/src/commands/pushpull.rs at line 476 [9.111631]

Replacement in pijul/src/commands/protocol.rs at line 49 [9.123281]

Insertion in pijul/src/commands/protocol.rs at line 250 [9.123281]

Insertion in pijul/src/commands/mod.rs at line 59 [9.133619]

Replacement in pijul/src/commands/log.rs at line 31 [9.134376]

File addition: lock.rs (-rw-r--r--)

Replacement in pijul/src/commands/init.rs at line 18 [9.136543]

Insertion in pijul/src/commands/init.rs at line 28 [9.136543]

Replacement in pijul/src/commands/git.rs at line 37 [9.137210]

Replacement in pijul/src/commands/git.rs at line 41 [9.137210]

Replacement in pijul/src/commands/git.rs at line 65 [9.137210]

Replacement in pijul/src/commands/git.rs at line 219 [9.137210]

Insertion in pijul/src/commands/git.rs at line 312 [9.137210]

Replacement in pijul/src/commands/fork.rs at line 25 [9.167873]

Insertion in pijul/src/commands/fork.rs at line 40 [9.167873]

Replacement in pijul/src/commands/file_operations.rs at line 24 [9.169058]

Insertion in pijul/src/commands/file_operations.rs at line 57 [9.169058]

Replacement in pijul/src/commands/file_operations.rs at line 78 [9.169058]

Replacement in pijul/src/commands/file_operations.rs at line 104 [9.169058]

Insertion in pijul/src/commands/file_operations.rs at line 151 [9.169058]

Replacement in pijul/src/commands/file_operations.rs at line 166 [9.169058]

Insertion in pijul/src/commands/file_operations.rs at line 193 [9.169058]

Replacement in pijul/src/commands/diff.rs at line 35 [9.173551]

Replacement in pijul/src/commands/debug.rs at line 18 [9.177758]

Replacement in pijul/src/commands/credit.rs at line 26 [9.178684]

Replacement in pijul/src/commands/credit.rs at line 28 [9.178684]

Replacement in pijul/src/commands/clone.rs at line 68 [9.182891]

Insertion in pijul/src/commands/clone.rs at line 108 [9.182891]

Replacement in pijul/src/commands/channel.rs at line 35 [9.186892]

Replacement in pijul/src/commands/channel.rs at line 39 [9.186892]

Replacement in pijul/src/commands/channel.rs at line 54 [9.186892]

Insertion in pijul/src/commands/channel.rs at line 64 [9.186892]

Replacement in pijul/src/commands/channel.rs at line 73 [9.186892]

Replacement in pijul/src/commands/channel.rs at line 77 [9.186892]

Insertion in pijul/src/commands/channel.rs at line 94 [9.186892]

Replacement in pijul/src/commands/change.rs at line 21 [9.189306]

Replacement in pijul/src/commands/archive.rs at line 85 [9.191083]

Replacement in pijul/src/commands/apply.rs at line 27 [9.194289]

Insertion in pijul/src/commands/apply.rs at line 91 [9.194289]

Replacement in pijul/Cargo.toml at line 4 [9.196374]

Insertion in pijul/Cargo.toml at line 32 [9.196374]