Integrating identity malleability

[?]

Jun 28, 2021, 8:59 AM

A3RM526Y7LUXNYW4TL56YKQ5GVOK2R5D7JJVTSQ6TT5MEXIR6YAAC

Dependencies

[2] R245EVN3 Do not print anything on broken pipe errors
[3] G6YXRFH2 Channel drop with tags
[4] TFK7CYFQ `pijul channel new` to create new, empty channels
[5] 5OGOE4VW Store the current channel in the pristine
[6] SMMBFECL Converting to the new patch format "online"
[7] IXC43DSH Fixing a bug in unrecord
[8] SAGSYAPX Various version bumps
[9] PSKXR4QE Do not load the entire change in memory in log
[10] ENKQ3QZG Forward the exit status messages from the SSH background loop to the client (solving hangs)
[11] EGSVRZJV Avoid converting between base32 and hash in pijul::commands::unrecord
[12] 5BB266P6 Optional colours in the global config file
[13] SZWBLWZ4 Reading ~/.ssh/config
[14] Y6EVFMTA Don't output files if they aren't in the current channel
[15] 6HNRL5RT detect non-utf8 text files
[16] 3S6LU2U5 abstract out FileMetadata (de)serialistion
[17] ZSF3YFZT encoded file deletion
[18] 3FTEGCMR add timestamp_validator to tag --timestamp option
[19] 6YMDOZIB Refactoring apply
[20] 7ZFRYVVQ Cargo.nix and formatting
[21] RRCSHAYZ Formatting
[22] LBVUI6AX Rename `ls` command to `list`
[23] OCBM7IFE New release: pijul-1.0.0-alpha.8
[24] 3WIQYEIS Fixing conflicts in Cargo.lock
[25] CCFJ7VO3 Renaming "Record" to "Hunk" in the changes
[26] WEHUTJUK Lockfile update
[27] 6DOXSHWG Cleanup, and version bump
[28] JMBGCWM5 Fixing a zombie, probably due to the new conflict algorithm
[29] UNZXTNSJ Change text format: order dependencies in the order they were on the channel at record time
[30] H3NAKE2I Adding num_cpus to Cargo.lock
[31] G65S7FAW Version bump and cleanup
[32] 2D7P2VKJ Change completions (where the whole progress bar story started)
[33] SXEYMYF7 Fixing the bad changes in history (unfortunately, by rebooting).
[34] ZBNKSYA6 Fixing a bus error when starting a transaction on a full disk
[35] KLBWKCUZ use ssh url syntax like git
[36] 2RXOCWUW Making libpijul deterministic (and getting rid of `rand`)
[37] CIEUBH46 Fixing an index-out-of-bounds error when serialising bad changes
[38] 23LVKATN Use pager crate for log output
[39] I24UEJQL Various post-fire fixes
[40] H62VFFJE Cargo.nix, and solving conflicts
[41] 3AMEP2Y5 More convenient interface for channels
[42] 367UBQ6K Forwarding SSH stderr, and progress bar for push
[43] GHO6DWPI Refactoring iterators
[44] TZ42DX3B Properly dropping a channel
[45] PJ7T2VFL Do not hang on locked repositories
[46] ZRUPLBBT Colours in diff and change: separating concerns and dependencies
[47] A3DMBJJA Upgrading the `git` subcommand to the latest Sanakirja and Libpijul
[48] MU5GSJAW Partial push and pull (WARNING: breaks the existing protocol)
[49] VO5OQW4W Removing anyhow in libpijul
[50] Y7YAFMFF Fix path prefix striping on Windows.
[51] WKX5S4Z4 remove unneccesary explicit lifetimes
[52] VQPAUKBQ channel switch as an alias to reset
[53] XWETQ4DE Upgrading versions
[54] I52XSRUH Massive cleanup, and simplification
[55] TKEVOH7H Fixing a bug when downloading changes, and making change download more efficient (more async)
[56] PGERZ3KJ Channel renaming (also do not create a new channel when recording on a channel that doesn't exist)
[57] HDGRZISM Version updates
[58] BZSC7VMY address clippy lints
[59] RXNT67OT Sanakirja version, and removing an unwrap
[60] 76PCXGML Pushing to, and pulling from the local repository
[61] AAXP2534 Tags: completing the subcommand
[62] WZVCLZKY address clippy lints
[63] SLJ3OHD4 unrecord: show list of changes if none were given as arguments
[64] H23LO7U7 a few more clippy lints addressed
[65] MFTN7GBW Pre-tags cleanup + fast Sanakirja
[66] IUGP6ZGB Add support for ~/.config/pijul even on macos
[67] FE5ES6Q4 Stop pushing/pulling if the remote returns an error
[68] TPEH2XNB 1.0.0-alpha.28, with Tokio 1.0
[69] UFCZKKLX Upgrading to the latest Sanakirja/Rand
[70] B3QWIGDE Fixing the Git features with the latest Pijul (+ conflicts in Cargo.toml)
[71] VYHHOEYH Versions and formatting
[72] W5HHTRPK Rename the `mv` command to `move`
[73] X6YFD4WV Do not download changes if we already have them
[74] TVVW53HZ Conflict resolution
[75] EEBKW7VT Keys and identities
[76] JL4WKA5P Implement the Sanakirja concurrency model in a cross-process way
[77] 33SQMZYX New versions of dependencies
[78] JACZWIJ6 Version bump
[79] YN63NUZO Sanakirja 1.0
[80] VZL5OHF5 Remove the obsolete `remote list` command
[81] QL6K2ZM3 Tags
[82] IIV3EL2X Cleanup, formatting, and fixing the Git feature
[83] GYXIF25T Proper parsing of URLs
[84] TFPETWTV Add config options for patch message templates
[85] VMPAOJS2 Don't output after pushing to a local channel
[86] I7VL7VPZ Minor cleanup
[87] JRENVH5D Reqwest 0.11
[88] UDHP4ZVB Fixing SSH asynchronicity issues
[89] Q45QHPO4 Feedback on network stuff
[90] T3S4P4ET Version updates
[91] NS36CJCO Validating timestamps in record
[92] XSEODPNE Fixing conflicts
[93] 7S4YD633 Change in semantic of the new Sanakirja compared to the previous one (get returns Some(…) even if the key is not found)
[94] SE4RJYBZ No pager on Windows (really not)
[95] K6GWUOD5 Styling progress bars
[96] CCLLB7OI Upgrading to Sanakirja 0.15 + version bump
[*] BNPSVXIC Friendlier progress bars
[*] HXEIH4UQ Pulling more than 100 changes at once
[*] FBXYP7QM Forgot to add remote::http
[*] KI2AFWOS Fixing a panic in pull
[*] SNZ3OAMC use native external subcommand support instead of hand-rolled one
[*] F6V27C3M Fixing the "old file optimisation" in record, after the move to parallelisable records
[*] OUWD436A Version bump

Change contents

replacement in pijul/src/repository.rs at line 46

[7.22907]→[7.922:1004](∅→∅),[7.1004]→[7.5753:5810](∅→∅)

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

[7.22907]

[7.23034]

pub fn find_root(cur: Option<PathBuf>) -> Result<Self, anyhow::Error> {
Self::find_root_with_dot_dir(cur, DOT_DIR)
replacement in pijul/src/repository.rs at line 50

[7.1238]→[7.1238:1279](∅→∅)

pub async fn find_root_with_dot_dir(

[7.23041]

[7.23076]

pub fn find_root_with_dot_dir(
edit in pijul/src/remote/ssh.rs at line 35

[7.145]

[7.26176]

)
.unwrap();

static ref ADDRESS_NOPATH: Regex = Regex::new(
r#"(ssh://)?((?P<user>[^@]+)@)?((?P<host>(\[([^\]]+)\])|([^:/]+)))(:(?P<port>\d+))?"#
replacement in pijul/src/remote/ssh.rs at line 52

[7.26375]→[7.0:50](∅→∅),[7.50]→[7.0:39](∅→∅),[7.26436]→[7.0:39](∅→∅)

pub fn ssh_remote(addr: &str) -> Option<Remote> {
let cap = ADDRESS.captures(addr)?;

[7.26375]

[7.26547]

pub fn ssh_remote(addr: &str, with_path: bool) -> Option<Remote> {
let cap = if with_path {
ADDRESS.captures(addr)?
} else {
ADDRESS_NOPATH.captures(addr)?
};
replacement in pijul/src/remote/ssh.rs at line 70

[7.27295]→[7.146:163](∅→∅)

let path = {

[7.27295]

[7.0]

let path = if with_path {
edit in pijul/src/remote/ssh.rs at line 83

[7.446]

[7.446]

} else {
""
edit in pijul/src/remote/ssh.rs at line 296

[7.339]

[7.339]

Id {
sender: Option<tokio::sync::oneshot::Sender<Option<libpijul::pristine::RemoteId>>>,
},
edit in pijul/src/remote/ssh.rs at line 319

[7.915]

[7.32378]

Prove {
key: libpijul::key::SKey,
sender: Option<tokio::sync::oneshot::Sender<()>>,
signed: bool,
},
Identities {
sender: Option<tokio::sync::mpsc::Sender<crate::Identity>>,
buf: Vec<u8>,
},
replacement in pijul/src/remote/ssh.rs at line 438

[7.1340]→[7.1340:1383](∅→∅)

session: thrussh::client::Session,

[7.1340]

[7.1383]

mut session: thrussh::client::Session,
edit in pijul/src/remote/ssh.rs at line 457

[7.2356]

[7.2356]

} else {
sender.send(None).unwrap_or(());
}
}
}
State::Id { ref mut sender } => {
debug!("state: State {:?}", data);
if let Some(sender) = sender.take() {
let line = if data.last() == Some(&10) {
libpijul::pristine::RemoteId::from_base32(&data[..data.len() - 1])
} else {
None
};
if let Some(b) = line {
sender.send(Some(b)).unwrap_or(());
edit in pijul/src/remote/ssh.rs at line 602

[7.7609]

[7.7609]

State::Prove {
ref mut key,
ref mut sender,
ref mut signed,
} => {
if let Ok(data) = std::str::from_utf8(&data) {
if *signed && !data.trim().is_empty() {
std::io::stderr().write_all(data.as_bytes())?;
} else {
let data = data.trim();
debug!("signing {:?}", data);
let s = key.sign_raw(data.as_bytes())?;
session.data(
channel,
thrussh::CryptoVec::from_slice(format!("prove {}\n", s).as_bytes()),
);
if let Some(sender) = sender.take() {
sender.send(()).unwrap_or(());
}
*signed = true;
}
}
}
State::Identities {
ref mut sender,
ref mut buf,
} => {
debug!("data = {:?}", data);
if data.ends_with(&[10]) {
let buf = if buf.is_empty() {
&data
} else {
buf.extend(&data);
&buf
};
for data in data.split(|c| *c == 10) {
if let Ok(p) = serde_json::from_slice(&buf) {
debug!("p = {:?}", p);
if let Some(ref mut sender) = sender {
sender.send(p).await?;
}
} else {
debug!("could not parse {:?}", std::str::from_utf8(&data));
*sender = None;
break;
}
}
} else {
buf.extend(&data);
}
}
edit in pijul/src/remote/ssh.rs at line 730

[7.37998]

[7.7980]

pub async fn get_id(&mut self) -> Result<Option<libpijul::pristine::RemoteId>, anyhow::Error> {
let (sender, receiver) = tokio::sync::oneshot::channel();
*self.state.lock().await = State::Id {
sender: Some(sender),
};
self.run_protocol().await?;
self.c
.data(format!("id {}\n", self.channel).as_bytes())
.await?;
Ok(receiver.await?)
}

pub async fn prove(&mut self, key: libpijul::key::SKey) -> Result<(), anyhow::Error> {
debug!("get_state");
let (sender, receiver) = tokio::sync::oneshot::channel();
let k = serde_json::to_string(&key.public_key())?;
*self.state.lock().await = State::Prove {
key,
sender: Some(sender),
signed: false,
};
self.run_protocol().await?;
self.c.data(format!("challenge {}\n", k).as_bytes()).await?;
Ok(receiver.await?)
}
edit in pijul/src/remote/ssh.rs at line 976

[7.52456]

[7.52456]

}

pub async fn update_identities(
&mut self,
rev: Option<u64>,
mut path: PathBuf,
) -> Result<u64, anyhow::Error> {
let (sender_, mut recv) = tokio::sync::mpsc::channel(100);
*self.state.lock().await = State::Identities {
sender: Some(sender_),
buf: Vec::new(),
};
self.run_protocol().await?;
if let Some(rev) = rev {
self.c
.data(format!("identities {}\n", rev).as_bytes())
.await?;
} else {
self.c.data("identities\n".as_bytes()).await?;
}
let mut revision = 0;
std::fs::create_dir_all(&path)?;
while let Some(id) = recv.recv().await {
path.push(&id.public_key.key);
debug!("recv identity: {:?} {:?}", id, path);
let mut id_file = std::fs::File::create(&path)?;
serde_json::to_writer_pretty(&mut id_file, &id)?;
path.pop();
revision = revision.max(id.last_modified);
}
debug!("done receiving");
Ok(revision)
edit in pijul/src/remote/mod.rs at line 40

[7.53103]

[7.53103]

with_path: bool,
replacement in pijul/src/remote/mod.rs at line 43

[7.53208]→[7.62:136](∅→∅)

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

[7.53208]

[7.53271]

unknown_remote(self_path, name, channel, no_cert_check, with_path).await
replacement in pijul/src/remote/mod.rs at line 45

[7.53288]→[7.137:211](∅→∅)

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

[7.53288]

[7.53351]

unknown_remote(self_path, name, channel, no_cert_check, with_path).await
edit in pijul/src/remote/mod.rs at line 55

[7.53459]

[7.53459]

with_path: bool,
replacement in pijul/src/remote/mod.rs at line 70

[7.543]→[7.543:604](∅→∅)

return if let Some(mut ssh) = ssh_remote(name) {

[7.543]

[7.604]

return if let Some(mut ssh) = ssh_remote(name, with_path) {
replacement in pijul/src/remote/mod.rs at line 104

[7.55181]→[7.2707:2753](∅→∅)

if let Some(mut ssh) = ssh_remote(name) {

[7.55181]

[7.833]

if let Some(mut ssh) = ssh_remote(name, with_path) {
replacement in pijul/src/remote/mod.rs at line 169

[7.56888]→[7.1509:1579](∅→∅)

let name = if let Some(name) = self.name() {
name

[7.56888]

[7.1579]

let id = if let Some(id) = self.get_id(txn).await? {
id
replacement in pijul/src/remote/mod.rs at line 174

[7.1636]→[7.56920:56987](∅→∅),[7.56920]→[7.56920:56987](∅→∅)

let mut remote = txn.open_or_create_remote(name).unwrap();

[7.1636]

[7.56987]

let mut remote = txn.open_or_create_remote(id, self.name().unwrap()).unwrap();
edit in pijul/src/remote/mod.rs at line 258

[7.8956]

[7.2110]

} else {
Ok(None)
}
}
RemoteRepo::None => unreachable!(),
}
}

async fn get_id<T: libpijul::TxnTExt>(
&mut self,
txn: &T,
) -> Result<Option<libpijul::pristine::RemoteId>, anyhow::Error> {
match *self {
RemoteRepo::Local(ref l) => l.get_id(),
RemoteRepo::Ssh(ref mut s) => s.get_id().await,
RemoteRepo::Http(ref h) => h.get_id().await,
RemoteRepo::LocalChannel(ref channel) => {
if let Some(channel) = txn.load_channel(&channel)? {
Ok(Some(*txn.id(&*channel.read().unwrap())))
edit in pijul/src/remote/mod.rs at line 373

[7.68182]

[7.68729]

}

async fn update_identities(
&mut self,
rev: Option<u64>,
path: PathBuf,
) -> Result<u64, anyhow::Error> {
let r = match *self {
RemoteRepo::Local(ref mut l) => l.update_identities(rev, path).await?,
RemoteRepo::Ssh(ref mut s) => s.update_identities(rev, path).await?,
RemoteRepo::Http(ref mut h) => h.update_identities(rev, path).await?,
RemoteRepo::LocalChannel(_) => 0,
RemoteRepo::None => unreachable!(),
};
Ok(r)
edit in pijul/src/remote/mod.rs at line 392

[7.118]

[7.68803]

remote: &RemoteRef<T>,
edit in pijul/src/remote/mod.rs at line 495

[7.1191]

[98.3637]
edit in pijul/src/remote/mod.rs at line 500

[99.321]

[7.1356]

debug!("Downloading identities");
let mut id_path = repo.path.clone();
id_path.push(DOT_DIR);
id_path.push("identities");
remote.set_id_revision(self.update_identities(None, id_path).await?)?;
edit in pijul/src/remote/mod.rs at line 584

[7.73272]

[7.73272]

let id = self.get_id(txn).await?.unwrap();
replacement in pijul/src/remote/mod.rs at line 586

[7.73321]→[7.2807:2848](∅→∅),[7.2848]→[7.73353:73416](∅→∅),[7.73353]→[7.73353:73416](∅→∅)

let name = self.name().unwrap();
let remote = txn.open_or_create_remote(name).unwrap();

[7.73321]

[7.74269]

let remote = txn.open_or_create_remote(id, self.name().unwrap()).unwrap();
replacement in pijul/src/remote/mod.rs at line 601

[7.74687]→[7.2665:2736](∅→∅)

self.pull(repo, txn, channel, &to_pull, &HashSet::new(), true)

[7.74687]

[7.2029]

self.pull(&remote, repo, txn, channel, &to_pull, &HashSet::new(), true)
replacement in pijul/src/remote/mod.rs at line 700

[7.78339]→[7.736:807](∅→∅),[7.807]→[7.8361:8428](∅→∅),[7.9745]→[7.8361:8428](∅→∅)

for x in txn.iter_remote(&remote_changes.lock()?.remote, 0)? {
let (_, p) = x?;
pullable.push(p.a.into())

[7.78339]

[7.78449]

{
let rem = remote_changes.lock()?;
for x in txn.iter_remote(&rem.remote, 0)? {
let (_, p) = x?;
pullable.push(p.a.into())
}
replacement in pijul/src/remote/mod.rs at line 707

[7.78459]→[7.2803:2894](∅→∅)

self.pull(repo, txn, local_channel, &pullable, &inodes, true)
.await?;

[7.78459]

[7.2742]

self.pull(
&remote_changes,
repo,
txn,
local_channel,
&pullable,
&inodes,
true,
)
.await?;
edit in pijul/src/remote/local.rs at line 43

[7.80605]

[7.80605]

pub fn get_id(&self) -> Result<Option<libpijul::pristine::RemoteId>, anyhow::Error> {
let txn = self.pristine.txn_begin()?;
if let Some(channel) = txn.load_channel(&self.channel)? {
Ok(Some(*txn.id(&*channel.read().unwrap())))
} else {
Ok(None)
}
}
edit in pijul/src/remote/local.rs at line 91

[7.4961]

[7.966]

debug!("from = {:?}", from);
replacement in pijul/src/remote/local.rs at line 94

[7.10802]→[7.81477:81504](∅→∅),[7.81477]→[7.81477:81504](∅→∅),[7.81705]→[7.10803:10869](∅→∅),[7.10869]→[7.81770:81807](∅→∅),[7.81770]→[7.81770:81807](∅→∅),[7.81807]→[7.10870:10952](∅→∅),[7.10952]→[7.8775:8838](∅→∅),[7.8838]→[7.11016:11116](∅→∅),[7.11016]→[7.11016:11116](∅→∅),[7.11116]→[7.81959:81977](∅→∅),[7.81959]→[7.81959:81977](∅→∅),[7.81977]→[7.8839:8909](∅→∅),[7.8909]→[7.82033:82051](∅→∅),[7.82033]→[7.82033:82051](∅→∅)

if n >= from {
let h_int = remote_txn.get_internal(h)?.unwrap();
if paths_.is_empty()
|| paths_.iter().any(|x| {
remote_txn
.get_touched_files(x, Some(h_int))
.unwrap()
.is_some()
})
{
txn.put_remote(remote, n, (h.into(), m.into()))?;
}

[7.10802]

[7.82051]

assert!(n >= from);
let h_int = remote_txn.get_internal(h)?.unwrap();
if paths_.is_empty()
|| paths_.iter().any(|x| {
remote_txn
.get_touched_files(x, Some(h_int))
.unwrap()
.is_some()
})
{
debug!("put_remote {:?} {:?} {:?}", n, h, m);
txn.put_remote(remote, n, (h.into(), m.into()))?;
edit in pijul/src/remote/local.rs at line 186

[7.83968]

[7.83968]

pub async fn update_identities(
&mut self,
_rev: Option<u64>,
mut path: PathBuf,
) -> Result<u64, anyhow::Error> {
let mut other_path = self.root.join(DOT_DIR);
other_path.push("identities");
let r = if let Ok(r) = std::fs::read_dir(&other_path) {
r
} else {
return Ok(0);
};
std::fs::create_dir_all(&path)?;
for id in r {
let id = id?;
let m = id.metadata()?;
let p = id.path();
path.push(p.file_name().unwrap());
if let Ok(ml) = std::fs::metadata(&path) {
if ml.modified()? < m.modified()? {
std::fs::remove_file(&path)?;
} else {
continue;
}
}
if std::fs::hard_link(&p, &path).is_err() {
std::fs::copy(&p, &path)?;
}
path.pop();
}
Ok(0)
}
edit in pijul/src/remote/http.rs at line 271

[101.1310]

[101.1310]

pub async fn get_id(&self) -> Result<Option<libpijul::pristine::RemoteId>, anyhow::Error> {
debug!("get_state {:?}", self.url);
let url = format!("{}/{}", self.url, super::DOT_DIR);
let q = [("channel", self.channel.clone()), ("id", String::new())];
let res = self
.client
.get(&url)
.query(&q)
.header(reqwest::header::USER_AGENT, USER_AGENT)
.send()
.await?;
if !res.status().is_success() {
bail!("HTTP error {:?}", res.status())
}
let resp = res.bytes().await?;
debug!("resp = {:?}", resp);
Ok(libpijul::pristine::RemoteId::from_bytes(&resp))
}
edit in pijul/src/remote/http.rs at line 341

[101.2760]

[7.6503]

}

pub async fn update_identities(
&mut self,
rev: Option<u64>,
mut path: PathBuf,
) -> Result<u64, anyhow::Error> {
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(&[(
"identities",
if let Some(rev) = rev {
format!("{}", rev)
} else {
String::new()
},
)])
.header(reqwest::header::USER_AGENT, USER_AGENT)
.send()
.await?;
if !res.status().is_success() {
bail!("HTTP error {:?}", res.status())
}
use serde_derive::*;
#[derive(Debug, Deserialize)]
struct Identities {
id: Vec<crate::Identity>,
rev: u64,
}
let resp: Identities = res.json().await?;

std::fs::create_dir_all(&path)?;
for id in resp.id.iter() {
path.push(&id.public_key.key);
debug!("recv identity: {:?} {:?}", id, path);
let mut id_file = std::fs::File::create(&path)?;
serde_json::to_writer_pretty(&mut id_file, &id)?;
path.pop();
}
Ok(resp.rev)
edit in pijul/src/main.rs at line 145

[102.169]

[2.0]

log::debug!("{:?}", e);
replacement in pijul/src/config.rs at line 20

[7.182]→[7.182:236](∅→∅)

pub key_path: String,
pub short_name: String,

[7.182]

[7.236]

pub key_path: Option<String>,
pub name: String,
replacement in pijul/src/config.rs at line 55

[7.90062]→[7.90062:90115](∅→∅)

pub fn load() -> Result<Global, anyhow::Error> {

[7.90062]

[7.544]

pub fn load() -> Result<(Global, u64), anyhow::Error> {
replacement in pijul/src/config.rs at line 58

[7.90243]→[7.20:60](∅→∅)

let s = std::fs::read(&dir)

[7.90243]

[7.60]

let (s, meta) = std::fs::read(&dir)
.and_then(|x| Ok((x, std::fs::metadata(&dir)?)))
replacement in pijul/src/config.rs at line 66

[7.357]→[7.357:401](∅→∅)

std::fs::read(&dir)

[7.357]

[7.401]

std::fs::read(&dir).and_then(|x| Ok((x, std::fs::metadata(&dir)?)))
replacement in pijul/src/config.rs at line 75

[7.651]→[7.595:639](∅→∅),[7.90487]→[7.595:639](∅→∅)

std::fs::read(&dir)

[7.651]

[7.90532]

std::fs::read(&dir).and_then(|x| Ok((x, std::fs::metadata(&dir)?)))
replacement in pijul/src/config.rs at line 82

[7.11517]→[7.11517:11539](∅→∅)

Ok(t)

[7.11517]

[7.11539]

let ts = meta
.modified()?
.duration_since(std::time::SystemTime::UNIX_EPOCH)
.unwrap()
.as_secs();
Ok((t, ts))
replacement in pijul/src/commands/unrecord.rs at line 36

[7.5722]→[7.5722:5791](∅→∅)

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

[7.5722]

[7.96236]

let mut repo = Repository::find_root(self.repo_path)?;
replacement in pijul/src/commands/unrecord.rs at line 60

[7.2745]→[7.2878:2936](∅→∅)

let cfg = crate::config::Global::load()?;

[7.2745]

[7.2936]

let (cfg, _) = crate::config::Global::load()?;
replacement in pijul/src/commands/tag.rs at line 53

[7.1582]→[7.1582:1651](∅→∅)

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

[7.1582]

[7.1651]

let mut repo = Repository::find_root(self.repo_path)?;
edit in pijul/src/commands/tag.rs at line 157

[7.686]

[7.686]

use libpijul::change::Author;
let mut b = std::collections::BTreeMap::new();
replacement in pijul/src/commands/tag.rs at line 160

[7.720]→[6.0:44](∅→∅)

authors.push(a.to_string().into());

[7.720]

[7.757]

b.insert("name".to_string(), a.to_string());
replacement in pijul/src/commands/tag.rs at line 165

[7.1002]→[6.45:84](∅→∅)

authors.push(k.key.into())

[7.1002]

[7.1034]

b.insert("key".to_string(), k.key);
} else {
bail!("No identity configured yet. Please use `pijul key` to create one")
edit in pijul/src/commands/tag.rs at line 170

[7.1050]

[7.5062]

authors.push(Author(b));
replacement in pijul/src/commands/reset.rs at line 41

[7.98218]→[7.6366:6431](∅→∅)

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

[7.98218]

[7.6431]

let repo = Repository::find_root(self.repo_path)?;
replacement in pijul/src/commands/record.rs at line 63

[7.102832]→[7.12658:12731](∅→∅)

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

[7.102832]

[7.102903]

let repo = Repository::find_root(self.repo_path.clone())?;
replacement in pijul/src/commands/record.rs at line 139

[7.1069]→[7.1069:1910](∅→∅)

let key = if let Some(mut dir) = crate::config::global_config_dir() {
dir.push("secretkey.json");
if let Ok(key) = std::fs::File::open(&dir) {
let k: libpijul::key::SecretKey = serde_json::from_reader(key)?;
let pass = if k.encryption.is_some() {
Some(rpassword::read_password_from_tty(Some(&format!(
"Password for {:?}: ",
dir
)))?)
} else {
None
};
k.load(pass.as_deref())?
} else {
bail!("Secret key not found, please use `pijul key generate` and try again")
}
} else {
bail!("Secret key not found, please use `pijul key generate` and try again")
};

[7.1069]

[7.1910]

let key = super::load_key()?;
edit in pijul/src/commands/record.rs at line 162

[103.1421]

[103.1421]

let mut path = repo.path.join(libpijul::DOT_DIR);
path.push("identities");
std::fs::create_dir_all(&path)?;
path.push("publickey.json");
std::fs::File::create(&path)?;
edit in pijul/src/commands/record.rs at line 208

[7.2097]

[7.2097]

let mut b = std::collections::BTreeMap::new();
replacement in pijul/src/commands/record.rs at line 210

[7.2140]→[6.85:129](∅→∅)

authors.push(a.clone().into());

[7.2140]

[7.2177]

b.insert("name".to_string(), a.clone());
replacement in pijul/src/commands/record.rs at line 215

[7.2438]→[6.130:173](∅→∅)

authors.push(k.key.into())

[7.2438]

[6.173]

b.insert("key".to_string(), k.key);
replacement in pijul/src/commands/record.rs at line 220

[7.2498]→[7.440:524](∅→∅),[7.105780]→[7.440:524](∅→∅)

let templates = config.as_ref().ok().and_then(|cfg| cfg.template.as_ref());

[7.2498]

[7.524]

authors.push(Author(b));
let templates = config
.as_ref()
.ok()
.and_then(|(cfg, _)| cfg.template.as_ref());
replacement in pijul/src/commands/pushpull.rs at line 36

[7.6472]→[7.10330:10395](∅→∅)

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

[7.6472]

[7.112314]

let repo = Repository::find_root(self.repo_path)?;
replacement in pijul/src/commands/pushpull.rs at line 42

[7.112523]→[7.12875:12924](∅→∅)

for r in txn.iter_remotes("")? {

[7.112523]

[7.12924]

for r in txn.iter_remotes(&libpijul::pristine::RemoteId::nil())? {
replacement in pijul/src/commands/pushpull.rs at line 44

[7.12956]→[7.112571:112628](∅→∅),[7.112571]→[7.112571:112628](∅→∅)

writeln!(stdout, " {}", r.name())?;

[7.12956]

[7.112628]

writeln!(stdout, " {}: {}", r.id(), r.lock().unwrap().path.as_str())?;
edit in pijul/src/commands/pushpull.rs at line 48

[7.112712]

[7.284]

let remote =
if let Some(r) = libpijul::pristine::RemoteId::from_base32(remote.as_bytes()) {
r
} else {
bail!("Could not parse identifier: {:?}", remote)
};
replacement in pijul/src/commands/pushpull.rs at line 55

[7.346]→[7.112773:112910](∅→∅),[7.112773]→[7.112773:112910](∅→∅)

if !txn.drop_named_remote(&remote)? {
writeln!(std::io::stderr(), "Remote not found: {:?}", remote)?

[7.346]

[7.112910]

if !txn.drop_named_remote(remote)? {
bail!("Remote not found: {:?}", remote)
replacement in pijul/src/commands/pushpull.rs at line 130

[7.1981]→[7.10396:10461](∅→∅)

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

[7.1981]

[7.114570]

let repo = Repository::find_root(self.repo_path)?;
edit in pijul/src/commands/pushpull.rs at line 166

[7.4483]

[7.4483]

true,
replacement in pijul/src/commands/pushpull.rs at line 291

[7.117585]→[7.6696:6765](∅→∅)

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

[7.117585]

[7.402]

let mut repo = Repository::find_root(self.repo_path)?;
edit in pijul/src/commands/pushpull.rs at line 321

[7.6107]

[7.6107]

true,
edit in pijul/src/commands/pushpull.rs at line 327

[7.8542]

[7.8542]

let remote_changes = remote.update_changelist(&mut txn, &self.path).await?;
edit in pijul/src/commands/pushpull.rs at line 329

[7.8601]→[7.8601:8689](∅→∅)

let remote_changes = remote.update_changelist(&mut txn, &self.path).await?;
replacement in pijul/src/commands/pushpull.rs at line 331

[7.11154]→[7.8690:8760](∅→∅),[7.118806]→[7.8690:8760](∅→∅)

if let Some((inodes_, remote_changes)) = remote_changes {

[7.11154]

[7.8760]

if let Some((inodes_, remote_changes)) = remote_changes.as_ref() {
edit in pijul/src/commands/pushpull.rs at line 408

[7.9951]

[7.9951]

&remote_changes.as_ref().unwrap().1,
edit in pijul/src/commands/protocol.rs at line 30

[7.123877]

[7.123877]

static ref ID: Regex = Regex::new(r#"id\s+(\S+)\s+"#).unwrap();
static ref IDENTITIES: Regex = Regex::new(r#"identities(\s+([0-9]+))?\s+"#).unwrap();
replacement in pijul/src/commands/protocol.rs at line 53

[7.6860]→[7.6860:6929](∅→∅)

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

[7.6860]

[7.457]

let mut repo = Repository::find_root(self.repo_path)?;
replacement in pijul/src/commands/protocol.rs at line 67

[7.125411]→[7.125411:125465](∅→∅)

if let Some(cap) = STATE.captures(&buf) {

[7.125411]

[7.125465]

if let Some(cap) = ID.captures(&buf) {
let channel = load_channel(&txn, &cap[1])?;
let c = channel.read().unwrap();
writeln!(o, "{}", c.id)?;
o.flush()?;
} else if let Some(cap) = STATE.captures(&buf) {
edit in pijul/src/commands/protocol.rs at line 241

[7.133104]

[7.133104]

} else if let Some(cap) = IDENTITIES.captures(&buf) {
let last_touched: u64 = if let Some(last) = cap.get(2) {
last.as_str().parse().unwrap()
} else {
0
};
let mut id_dir = repo.path.clone();
id_dir.push(DOT_DIR);
id_dir.push("identities");
let r = if let Ok(r) = std::fs::read_dir(&id_dir) {
r
} else {
continue;
};
for id in r {
let id = id?;
let m = id.metadata()?;
let p = id.path();
debug!("{:?}", p);
let mod_ts = m
.modified()?
.duration_since(std::time::SystemTime::UNIX_EPOCH)
.unwrap()
.as_secs();
if mod_ts >= last_touched {
let mut done = HashSet::new();
if p.file_name() == Some("publickey.json".as_ref()) {
let public_key: libpijul::key::PublicKey =
if let Some(mut dir) = crate::config::global_config_dir() {
dir.push("publickey.json");
let mut pkf = std::fs::File::open(&dir)?;
serde_json::from_reader(&mut pkf)?
} else {
continue;
};
if !done.insert(public_key.key.clone()) {
continue;
}
if let Ok((config, last_modified)) = crate::config::Global::load() {
serde_json::to_writer(
&mut o,
&crate::Identity {
public_key,
email: config.author.email,
name: config.author.full_name,
login: config.author.name,
origin: String::new(),
last_modified,
},
)
.unwrap();
writeln!(o)?;
o.flush()?;
} else {
debug!("no global config");
}
} else {
let mut idf = if let Ok(f) = std::fs::File::open(&p) {
f
} else {
continue;
};
let id: Result<crate::Identity, _> = serde_json::from_reader(&mut idf);
if let Ok(id) = id {
if !done.insert(id.public_key.key.clone()) {
continue;
}
serde_json::to_writer(&mut o, &id).unwrap();
writeln!(o)?;
o.flush()?;
}
}
}
}
writeln!(o)?;
o.flush()?;
edit in pijul/src/commands/mod.rs at line 1

[7.133619]

[7.133620]

use anyhow::bail;
replacement in pijul/src/commands/mod.rs at line 190

[7.4328]→[6.285:331](∅→∅)

write!(v, "{}", a.name).unwrap();

[7.4328]

[7.4369]

if let Some(s) = a.0.get("name") {
write!(v, "{}", s).unwrap()
} else if let Some(k) = a.0.get("key") {
write!(v, "{}", k).unwrap()
}
replacement in pijul/src/commands/mod.rs at line 229

[6.420]→[6.420:480](∅→∅)

public_key: libpijul::key::PublicKey,
name: String,

[6.420]

[6.480]

pub public_key: libpijul::key::PublicKey,
pub login: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
replacement in pijul/src/commands/mod.rs at line 234

[6.544]→[6.544:564](∅→∅)

origin: String,

[6.544]

[6.564]

pub origin: String,
replacement in pijul/src/commands/mod.rs at line 236

[6.627]→[6.627:654](∅→∅)

email: Option<String>,

[6.627]

[7.5215]

pub email: Option<String>,
pub last_modified: u64,
}

fn load_key() -> Result<libpijul::key::SKey, anyhow::Error> {
if let Some(mut dir) = crate::config::global_config_dir() {
dir.push("secretkey.json");
if let Ok(key) = std::fs::File::open(&dir) {
let k: libpijul::key::SecretKey = serde_json::from_reader(key)?;
let pass = if k.encryption.is_some() {
Some(rpassword::read_password_from_tty(Some(&format!(
"Password for {:?}: ",
dir
)))?)
} else {
None
};
Ok(k.load(pass.as_deref())?)
} else {
bail!("Secret key not found, please use `pijul key generate` and try again")
}
} else {
bail!("Secret key not found, please use `pijul key generate` and try again")
}
replacement in pijul/src/commands/log.rs at line 34

[7.7083]→[7.12835:12911](∅→∅)

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

[7.7083]

[7.135006]

let repo = Repository::find_root(self.repo_path)?;
replacement in pijul/src/commands/log.rs at line 57

[6.772]→[6.772:985](∅→∅)

let mut id_path = if let Some(mut dir) = crate::config::global_config_dir() {
dir.push("identities");
Some(dir)
} else {
None
};

[6.772]

[6.985]

let mut id_path = repo.path.join(libpijul::DOT_DIR);
id_path.push("identities");
replacement in pijul/src/commands/log.rs at line 68

[6.1073]→[6.1073:1532](∅→∅)

for auth in header.authors.into_iter() {
let auth = match authors.entry(auth.name) {
Entry::Occupied(e) => e.into_mut(),
Entry::Vacant(e) => {
let mut id = None;
if let Some(ref mut p) = id_path {
p.push(e.key());
if let Ok(f) = std::fs::File::open(&p) {

[6.1073]

[6.1532]

for mut auth in header.authors.into_iter() {
let auth = if let Some(k) = auth.0.remove("key") {
match authors.entry(k) {
Entry::Occupied(e) => e.into_mut(),
Entry::Vacant(e) => {
let mut id = None;
id_path.push(e.key());
if let Ok(f) = std::fs::File::open(&id_path) {
replacement in pijul/src/commands/log.rs at line 82

[6.1839]→[6.1839:2153](∅→∅)

p.pop();
}
if let Some(id) = id {
e.insert(id.name)
} else {
let k = e.key().to_string();
e.insert(k)

[6.1839]

[6.2153]

id_path.pop();
if let Some(id) = id {
e.insert(id.login)
} else {
let k = e.key().to_string();
e.insert(k)
}
edit in pijul/src/commands/log.rs at line 91

[6.2209]

[6.2209]

} else {
auth.0.get("name").unwrap()
edit in pijul/src/commands/key.rs at line 2

[7.2581]

[7.2581]

use crate::repository::Repository;
edit in pijul/src/commands/key.rs at line 4

[7.2599]→[7.2599:2621](∅→∅)

use chrono::Datelike;
edit in pijul/src/commands/key.rs at line 6

[7.2653]

[7.2653]
replacement in pijul/src/commands/key.rs at line 21

[6.2599]→[6.2599:2621](∅→∅)

name: String,

[6.2599]

[6.2621]

login: String,
},
Prove {
#[clap(short = 'k')]
no_cert_check: bool,
remote: String,
replacement in pijul/src/commands/key.rs at line 33

[7.2956]→[6.2629:2689](∅→∅)

Some(SubCommand::Generate { email, name }) => {

[7.2956]

[7.3003]

Some(SubCommand::Generate { email, login }) => {
edit in pijul/src/commands/key.rs at line 42

[7.3372]→[7.3372:3509](∅→∅)

let expires = chrono::Utc::now();
let expires = expires.with_year(expires.year() + 1).unwrap();
replacement in pijul/src/commands/key.rs at line 51

[7.3875]→[7.3875:3943](∅→∅)

let k = libpijul::key::SKey::generate(expires);

[7.3875]

[7.3943]

let k = libpijul::key::SKey::generate(None);
replacement in pijul/src/commands/key.rs at line 76

[6.3399]→[6.3399:3433](∅→∅)

name,

[6.3399]

[6.3433]

login,
edit in pijul/src/commands/key.rs at line 78

[6.3468]

[6.3468]

name: None,
last_modified: std::time::SystemTime::now()
.duration_since(std::time::SystemTime::UNIX_EPOCH)
.unwrap()
.as_secs(),
edit in pijul/src/commands/key.rs at line 88

[7.4532]

[7.4532]

Some(SubCommand::Prove {
remote,
no_cert_check,
}) => {
let mut remote = if let Ok(repo) = Repository::find_root(None) {
use crate::remote::*;
if let RemoteRepo::Ssh(ssh) = repo
.remote(None, &remote, crate::DEFAULT_CHANNEL, no_cert_check, false)
.await?
{
ssh
} else {
bail!("No such remote: {}", remote)
}
} else if let Some(mut ssh) = crate::remote::ssh::ssh_remote(&remote, false) {
ssh.connect(&remote, crate::DEFAULT_CHANNEL).await?
} else {
bail!("No such remote: {}", remote)
};
let key = super::load_key()?;
remote.prove(key).await?;
}
replacement in pijul/src/commands/fork.rs at line 26

[7.14628]→[7.13138:13203](∅→∅)

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

[7.14628]

[7.168420]

let repo = Repository::find_root(self.repo_path)?;
replacement in pijul/src/commands/file_operations.rs at line 29

[7.14796]→[7.13275:13348](∅→∅)

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

[7.14796]

[7.169474]

let repo = Repository::find_root(self.repo_path.clone())?;
replacement in pijul/src/commands/file_operations.rs at line 103

[7.14968]→[7.13349:13425](∅→∅)

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

[7.14968]

[7.170979]

let repo = Repository::find_root(self.repo_path)?;
replacement in pijul/src/commands/file_operations.rs at line 131

[7.15113]→[7.13426:13499](∅→∅)

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

[7.15113]

[7.19543]

let repo = Repository::find_root(self.repo_path.clone())?;
replacement in pijul/src/commands/file_operations.rs at line 198

[7.15285]→[7.13500:13573](∅→∅)

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

[7.15285]

[7.732]

let repo = Repository::find_root(self.repo_path.clone())?;
replacement in pijul/src/commands/diff.rs at line 37

[7.15461]→[7.19939:20012](∅→∅)

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

[7.15461]

[7.787]

let repo = Repository::find_root(self.repo_path.clone())?;
replacement in pijul/src/commands/diff.rs at line 270

[7.483]→[7.483:539](∅→∅)

if let Ok(global) = crate::config::Global::load() {

[7.483]

[7.539]

if let Ok((global, _)) = crate::config::Global::load() {
replacement in pijul/src/commands/debug.rs at line 21

[7.15597]→[7.15597:15662](∅→∅)

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

[7.15597]

[7.178130]

let repo = Repository::find_root(self.repo_path)?;
edit in pijul/src/commands/debug.rs at line 39

[7.21348]

[7.21348]

libpijul::pristine::debug_remotes(&txn);
replacement in pijul/src/commands/credit.rs at line 28

[7.179239]→[5.3507:3572](∅→∅)

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

[7.179239]

[7.179302]

let repo = Repository::find_root(self.repo_path)?;
replacement in pijul/src/commands/clone.rs at line 38

[7.183871]→[7.183871:183896](∅→∅),[7.183896]→[7.8109:8231](∅→∅)

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

[7.183871]

[7.183995]

let mut remote = crate::remote::unknown_remote(
None,
&self.remote,
&self.channel,
self.no_cert_check,
true,
)
.await?;
replacement in pijul/src/commands/channel.rs at line 42

[7.187735]→[7.15969:16042](∅→∅)

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

[7.187735]

[7.187735]

let repo = Repository::find_root(self.repo_path)?;
replacement in pijul/src/commands/channel.rs at line 57

[7.188244]→[7.13907:13980](∅→∅)

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

[7.188244]

[5.3917]

let repo = Repository::find_root(self.repo_path)?;
replacement in pijul/src/commands/channel.rs at line 79

[7.188456]→[5.4038:4111](∅→∅)

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

[7.188456]

[7.960]

let repo = Repository::find_root(self.repo_path)?;
replacement in pijul/src/commands/channel.rs at line 99

[4.155]→[4.155:228](∅→∅)

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

[4.155]

[4.228]

let repo = Repository::find_root(self.repo_path)?;
replacement in pijul/src/commands/change.rs at line 22

[7.16397]→[7.14055:14139](∅→∅)

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

[7.16397]

[7.189800]

let repo = Repository::find_root(self.repo_path.clone())?;
edit in pijul/src/commands/archive.rs at line 87

[7.192511]

[7.192511]

true,
replacement in pijul/src/commands/archive.rs at line 107

[7.8987]→[7.16492:16572](∅→∅)

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

[7.8987]

[7.193066]

if let Ok(repo) = Repository::find_root(self.repo_path.clone()) {
replacement in pijul/src/commands/apply.rs at line 31

[7.16631]→[7.23476:23541](∅→∅)

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

[7.16631]

[7.1086]

let repo = Repository::find_root(self.repo_path)?;
replacement in pijul/Cargo.toml at line 66

[7.1679]→[7.590:646](∅→∅)

reqwest = { version = "0.11", features = [ "stream" ] }

[7.1679]

[7.197856]

reqwest = { version = "0.11", features = [ "stream", "json" ] }
edit in libpijul/src/tag.rs at line 216

[7.12489]

[7.12489]

id: {
let mut rng = rand::thread_rng();
use rand::Rng;
let mut m = crate::pristine::RemoteId([0; 16]);
for m in m.0.iter_mut() {
*m = rng.gen()
}
m
},
replacement in libpijul/src/pristine/sanakirja.rs at line 269

[7.60363]→[7.22798:22831](∅→∅),[7.22831]→[7.60396:60428](∅→∅),[7.60396]→[7.60396:60428](∅→∅)

channels: UDb<SmallStr, T8>,
remotes: UDb<SmallStr, T3>,

[7.60363]

[7.61849]

channels: UDb<SmallStr, SerializedChannel>,
remotes: UDb<RemoteId, SerializedRemote>,
replacement in libpijul/src/pristine/sanakirja.rs at line 273

[7.61926]→[7.61926:61990](∅→∅)

open_remotes: Mutex<HashMap<SmallString, RemoteRef<Self>>>,

[7.61926]

[7.61990]

open_remotes: Mutex<HashMap<RemoteId, RemoteRef<Self>>>,
edit in libpijul/src/pristine/sanakirja.rs at line 278

[7.537862]

[7.537862]

direct_repr!(SerializedPublicKey);
replacement in libpijul/src/pristine/sanakirja.rs at line 318

[7.62616]→[7.62616:62787](∅→∅)

let graph: Db<Vertex<ChangeId>, SerializedEdge> = Db::from_page(tup.0[0].into());
let changes: Db<ChangeId, L64> = Db::from_page(tup.0[1].into());

[7.62616]

[7.7637]

let graph: Db<Vertex<ChangeId>, SerializedEdge> = Db::from_page(tup.graph.into());
let changes: Db<ChangeId, L64> = Db::from_page(tup.changes.into());
replacement in libpijul/src/pristine/sanakirja.rs at line 321

[7.7710]→[7.7710:7759](∅→∅),[7.7759]→[7.62893:62979](∅→∅),[7.62893]→[7.62893:62979](∅→∅),[7.62979]→[7.22832:22914](∅→∅)

UDb::from_page(tup.0[2].into());
let states: UDb<SerializedMerkle, L64> = UDb::from_page(tup.0[3].into());
let tags: UDb<L64, SerializedHash> = UDb::from_page(tup.0[4].into());

[7.7710]

[7.62979]

UDb::from_page(tup.revchanges.into());
let states: UDb<SerializedMerkle, L64> = UDb::from_page(tup.states.into());
let tags: UDb<L64, SerializedHash> = UDb::from_page(tup.tags.into());
replacement in libpijul/src/pristine/sanakirja.rs at line 339

[7.63796]→[7.63796:64103](∅→∅)

debug!("check: remote name: {:?}", name.as_str());
let remote: UDb<SmallStr, T3> = UDb::from_page(tup.0[0].into());
let rev: UDb<SerializedHash, L64> = UDb::from_page(tup.0[1].into());
let states: UDb<SerializedMerkle, L64> = UDb::from_page(tup.0[2].into());

[7.63796]

[7.64103]

debug!("check: remote name: {:?}", name);
let remote: UDb<RemoteId, SerializedRemote> = UDb::from_page(tup.remote.into());
let rev: UDb<SerializedHash, L64> = UDb::from_page(tup.rev.into());
let states: UDb<SerializedMerkle, L64> = UDb::from_page(tup.states.into());
edit in libpijul/src/pristine/sanakirja.rs at line 678

[7.39221]

[7.39221]

pub id: RemoteId,
edit in libpijul/src/pristine/sanakirja.rs at line 691

[7.39395]

[7.39395]

}
fn id<'a>(&self, c: &'a Self::Channel) -> &'a RemoteId {
&c.id
replacement in libpijul/src/pristine/sanakirja.rs at line 1120

[7.76381]→[7.76381:76627](∅→∅),[7.76627]→[7.24780:24943](∅→∅)

graph: Db::from_page(tup.0[0].into()),
changes: Db::from_page(tup.0[1].into()),
revchanges: UDb::from_page(tup.0[2].into()),
states: UDb::from_page(tup.0[3].into()),
tags: UDb::from_page(tup.0[4].into()),
apply_counter: tup.0[5].into(),
last_modified: tup.0[6].into(),

[7.76381]

[7.76731]

graph: Db::from_page(tup.graph.into()),
changes: Db::from_page(tup.changes.into()),
revchanges: UDb::from_page(tup.revchanges.into()),
states: UDb::from_page(tup.states.into()),
tags: UDb::from_page(tup.tags.into()),
apply_counter: tup.apply_counter.into(),
last_modified: tup.last_modified.into(),
id: tup.id,
replacement in libpijul/src/pristine/sanakirja.rs at line 1244

[7.550319]→[7.47472:47573](∅→∅),[7.47573]→[7.550386:550434](∅→∅),[7.550386]→[7.550386:550434](∅→∅)

fn load_remote(&self, name: &str) -> Result<Option<RemoteRef<Self>>, TxnErr<Self::GraphError>> {
let name = SmallString::from_str(name);

[7.550319]

[7.63137]

fn load_remote(
&self,
name: &RemoteId,
) -> Result<Option<RemoteRef<Self>>, TxnErr<Self::GraphError>> {
let name = name.to_owned();
replacement in libpijul/src/pristine/sanakirja.rs at line 1251

[7.8342]→[7.8342:8411](∅→∅)

Some((name_, remote)) if name.as_ref() == name_ => {

[7.8342]

[7.8411]

Some((name_, remote)) if name == *name_ => {
replacement in libpijul/src/pristine/sanakirja.rs at line 1254

[7.8517]→[7.8517:8718](∅→∅)

remote: UDb::from_page(remote.0[0].into()),
rev: UDb::from_page(remote.0[1].into()),
states: UDb::from_page(remote.0[2].into()),

[7.8517]

[7.8718]

remote: UDb::from_page(remote.remote.into()),
rev: UDb::from_page(remote.rev.into()),
states: UDb::from_page(remote.states.into()),
id_rev: remote.id_rev.into(),
path: remote.path.to_owned(),
replacement in libpijul/src/pristine/sanakirja.rs at line 1276

[7.63261]→[7.9416:9460](∅→∅),[7.9416]→[7.9416:9460](∅→∅)

name: name.clone(),

[7.63261]

[7.9460]

id: name,
replacement in libpijul/src/pristine/sanakirja.rs at line 1287

[7.551320]→[7.24944:25125](∅→∅)

type Channels = UDb<SmallStr, T8>;
type ChannelsCursor = ::sanakirja::btree::cursor::Cursor<SmallStr, T8, UP<SmallStr, T8>>;
sanakirja_cursor!(channels, SmallStr, T8,);

[7.551320]

[7.47694]

type Channels = UDb<SmallStr, SerializedChannel>;
type ChannelsCursor = ::sanakirja::btree::cursor::Cursor<
SmallStr,
SerializedChannel,
UP<SmallStr, SerializedChannel>,
>;
sanakirja_cursor!(channels, SmallStr, SerializedChannel);
replacement in libpijul/src/pristine/sanakirja.rs at line 1304

[7.552165]→[7.79317:79494](∅→∅)

type Remotes = UDb<SmallStr, T3>;
type RemotesCursor = ::sanakirja::btree::cursor::Cursor<SmallStr, T3, UP<SmallStr, T3>>;
sanakirja_cursor!(remotes, SmallStr, T3);

[7.552165]

[7.47960]

type Remotes = UDb<RemoteId, SerializedRemote>;
type RemotesCursor = ::sanakirja::btree::cursor::Cursor<
RemoteId,
SerializedRemote,
UP<RemoteId, SerializedRemote>,
>;
sanakirja_cursor!(remotes, RemoteId, SerializedRemote);
replacement in libpijul/src/pristine/sanakirja.rs at line 1313

[7.48007]→[7.48007:48028](∅→∅)

start: &str,

[7.48007]

[7.48028]

start: &RemoteId,
edit in libpijul/src/pristine/sanakirja.rs at line 1315

[7.48101]→[7.552695:552744](∅→∅),[7.552695]→[7.552695:552744](∅→∅)

let name = SmallString::from_str(start);
replacement in libpijul/src/pristine/sanakirja.rs at line 1316

[7.79575]→[7.79575:79620](∅→∅)

cursor.set(&self.txn, &name, None)?;

[7.79575]

[7.79620]

cursor.set(&self.txn, start, None)?;
replacement in libpijul/src/pristine/sanakirja.rs at line 1367

[7.48549]→[7.48549:48569](∅→∅)

name: &str,

[7.48549]

[7.48569]

name: RemoteId,
replacement in libpijul/src/pristine/sanakirja.rs at line 1369

[7.48638]→[7.555312:555360](∅→∅),[7.555312]→[7.555312:555360](∅→∅)

let name = SmallString::from_str(name);

[7.48638]

[7.63262]

let name = name.to_owned();
replacement in libpijul/src/pristine/sanakirja.rs at line 1372

[7.9679]→[7.9679:9748](∅→∅)

Some((name_, remote)) if name_ == name.as_ref() => {

[7.9679]

[7.9748]

Some((name_, remote)) if *name_ == name => {
replacement in libpijul/src/pristine/sanakirja.rs at line 1375

[7.63390]→[7.9846:10059](∅→∅),[7.9846]→[7.9846:10059](∅→∅)

remote: UDb::from_page(remote.0[0].into()),
rev: UDb::from_page(remote.0[1].into()),
states: UDb::from_page(remote.0[2].into()),

[7.63390]

[7.10059]

remote: UDb::from_page(remote.remote.into()),
rev: UDb::from_page(remote.rev.into()),
states: UDb::from_page(remote.states.into()),
id_rev: remote.id_rev.into(),
path: remote.path.to_owned(),
replacement in libpijul/src/pristine/sanakirja.rs at line 1381

[7.10088]→[7.10088:10132](∅→∅)

name: name.clone(),

[7.10088]

[7.10132]

id: name,
replacement in libpijul/src/pristine/sanakirja.rs at line 1774

[7.66748]→[7.137:407](∅→∅),[7.137]→[7.137:407](∅→∅),[7.407]→[7.25707:25888](∅→∅)

graph: Db::from_page(b.0[0].into()),
changes: Db::from_page(b.0[1].into()),
revchanges: UDb::from_page(b.0[2].into()),
states: UDb::from_page(b.0[3].into()),
tags: UDb::from_page(b.0[4].into()),
apply_counter: b.0[5].into(),
last_modified: b.0[6].into(),

[7.66748]

[7.465]

graph: Db::from_page(b.graph.into()),
changes: Db::from_page(b.changes.into()),
revchanges: UDb::from_page(b.revchanges.into()),
states: UDb::from_page(b.states.into()),
tags: UDb::from_page(b.tags.into()),
apply_counter: b.apply_counter.into(),
last_modified: b.last_modified.into(),
id: b.id,
edit in libpijul/src/pristine/sanakirja.rs at line 1793

[7.25962]

[7.11541]

id: {
let mut rng = rand::thread_rng();
use rand::Rng;
let mut x = RemoteId([0; 16]);
for x in x.0.iter_mut() {
*x = rng.gen()
}
x
},
edit in libpijul/src/pristine/sanakirja.rs at line 1850

[7.89616]

[7.89616]

id: {
let mut rng = rand::thread_rng();
use rand::Rng;
let mut x = RemoteId([0; 16]);
for x in x.0.iter_mut() {
*x = rng.gen()
}
x
},
replacement in libpijul/src/pristine/sanakirja.rs at line 1923

[7.803]→[7.803:1017](∅→∅),[7.1017]→[3.31:85](∅→∅)

Db::from_page(chan.0[0].into()),
Db::from_page(chan.0[1].into()),
UDb::from_page(chan.0[2].into()),
UDb::from_page(chan.0[3].into()),
UDb::from_page(chan.0[4].into()),

[7.803]

[7.1017]

Db::from_page(chan.graph.into()),
Db::from_page(chan.changes.into()),
UDb::from_page(chan.revchanges.into()),
UDb::from_page(chan.states.into()),
UDb::from_page(chan.tags.into()),
replacement in libpijul/src/pristine/sanakirja.rs at line 1986

[7.567999]→[7.53162:53261](∅→∅),[7.53261]→[7.90733:90802](∅→∅)

fn open_or_create_remote(&mut self, name: &str) -> Result<RemoteRef<Self>, Self::GraphError> {
let name = crate::small_string::SmallString::from_str(name);

[7.567999]

[7.568157]

fn open_or_create_remote(
&mut self,
id: RemoteId,
path: &str,
) -> Result<RemoteRef<Self>, Self::GraphError> {
replacement in libpijul/src/pristine/sanakirja.rs at line 1992

[7.568188]→[7.67513:67583](∅→∅)

match self.open_remotes.lock().unwrap().entry(name.clone()) {

[7.568188]

[7.568255]

match self.open_remotes.lock().unwrap().entry(id) {
replacement in libpijul/src/pristine/sanakirja.rs at line 1994

[7.568289]→[7.12377:12543](∅→∅)

let r = match btree::get(&self.txn, &self.remotes, &name, None)? {
Some((name_, remote)) if name_ == name.as_ref() => RemoteRef {

[7.568289]

[7.67584]

let r = match btree::get(&self.txn, &self.remotes, &id, None)? {
Some((name_, remote)) if *name_ == id => RemoteRef {
replacement in libpijul/src/pristine/sanakirja.rs at line 1997

[7.67641]→[7.12601:12814](∅→∅),[7.12601]→[7.12601:12814](∅→∅)

remote: UDb::from_page(remote.0[0].into()),
rev: UDb::from_page(remote.0[1].into()),
states: UDb::from_page(remote.0[2].into()),

[7.67641]

[7.12814]

remote: UDb::from_page(remote.remote.into()),
rev: UDb::from_page(remote.rev.into()),
states: UDb::from_page(remote.states.into()),
id_rev: remote.id_rev.into(),
path: SmallString::from_str(path),
replacement in libpijul/src/pristine/sanakirja.rs at line 2003

[7.12843]→[7.12843:12887](∅→∅)

name: name.clone(),

[7.12843]

[7.12887]

id,
edit in libpijul/src/pristine/sanakirja.rs at line 2011

[7.13266]

[7.13266]

id_rev: 0u64.into(),
path: SmallString::from_str(path),
replacement in libpijul/src/pristine/sanakirja.rs at line 2014

[7.13299]→[7.13299:13347](∅→∅)

name: name.clone(),

[7.13299]

[7.13347]

id,
replacement in libpijul/src/pristine/sanakirja.rs at line 2027

[7.569492]→[7.67704:67720](∅→∅)

Ok(self

[7.569492]

[7.67720]

Ok(self.open_remotes.lock().unwrap().get(&id).unwrap().clone())
}

fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, Self::GraphError> {
let r = self
replacement in libpijul/src/pristine/sanakirja.rs at line 2035

[7.67788]→[7.67788:67856](∅→∅),[7.67856]→[7.569559:569566](∅→∅),[7.569559]→[7.569559:569566](∅→∅),[7.569566]→[7.53284:53375](∅→∅),[7.16397]→[7.569654:569694](∅→∅),[7.53375]→[7.569654:569694](∅→∅),[7.569654]→[7.569654:569694](∅→∅),[7.569694]→[7.67857:67931](∅→∅)

.get(&name)
.unwrap()
.clone())
}

fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, Self::GraphError> {
let name = remote.name.clone();
let r = self.open_remotes.lock().unwrap().remove(&name).unwrap();

[7.67788]

[7.569765]

.remove(&remote.id)
.unwrap();
replacement in libpijul/src/pristine/sanakirja.rs at line 2039

[7.67981]→[7.92084:92155](∅→∅),[7.569845]→[7.92084:92155](∅→∅)

Ok(btree::del(&mut self.txn, &mut self.remotes, &name, None)?)

[7.67981]

[7.570023]

Ok(btree::del(&mut self.txn, &mut self.remotes, &r.id, None)?)
replacement in libpijul/src/pristine/sanakirja.rs at line 2042

[7.570030]→[7.53376:53460](∅→∅),[7.16477]→[7.570111:570159](∅→∅),[7.53460]→[7.570111:570159](∅→∅),[7.570111]→[7.570111:570159](∅→∅),[7.570159]→[7.67982:68057](∅→∅)

fn drop_named_remote(&mut self, name: &str) -> Result<bool, Self::GraphError> {
let name = SmallString::from_str(name);
if let Some(r) = self.open_remotes.lock().unwrap().remove(&name) {

[7.570030]

[7.68057]

fn drop_named_remote(&mut self, id: RemoteId) -> Result<bool, Self::GraphError> {
if let Some(r) = self.open_remotes.lock().unwrap().remove(&id) {
replacement in libpijul/src/pristine/sanakirja.rs at line 2046

[7.570293]→[7.92156:92227](∅→∅)

Ok(btree::del(&mut self.txn, &mut self.remotes, &name, None)?)

[7.570293]

[7.570471]

Ok(btree::del(&mut self.txn, &mut self.remotes, &id, None)?)
edit in libpijul/src/pristine/sanakirja.rs at line 2096

[7.93231]→[7.572021:572022](∅→∅),[7.572021]→[7.572021:572022](∅→∅)
replacement in libpijul/src/pristine/sanakirja.rs at line 2113

[7.93486]→[7.93486:93724](∅→∅),[7.93724]→[7.26159:26316](∅→∅)

graph: Db::from_page(c.0[0].into()),
changes: Db::from_page(c.0[1].into()),
revchanges: UDb::from_page(c.0[2].into()),
states: UDb::from_page(c.0[3].into()),
tags: UDb::from_page(c.0[4].into()),
apply_counter: c.0[5].into(),
last_modified: c.0[6].into(),

[7.93486]

[7.93824]

graph: Db::from_page(c.graph.into()),
changes: Db::from_page(c.changes.into()),
revchanges: UDb::from_page(c.revchanges.into()),
states: UDb::from_page(c.states.into()),
tags: UDb::from_page(c.tags.into()),
apply_counter: c.apply_counter.into(),
last_modified: c.last_modified.into(),
id: c.id,
replacement in libpijul/src/pristine/sanakirja.rs at line 2144

[7.13754]→[7.26317:26339](∅→∅),[7.26339]→[7.94110:94266](∅→∅),[7.94110]→[7.94110:94266](∅→∅),[7.94266]→[7.26340:26376](∅→∅),[7.26376]→[7.94266:94350](∅→∅),[7.94266]→[7.94266:94350](∅→∅),[7.94350]→[7.26377:26402](∅→∅),[7.26402]→[7.94350:94362](∅→∅),[7.94350]→[7.94350:94362](∅→∅),[7.94362]→[7.26403:26479](∅→∅)

let t8 = T8([
channel.graph.db.into(),
channel.changes.db.into(),
channel.revchanges.db.into(),
channel.states.db.into(),
channel.tags.db.into(),
channel.apply_counter.into(),
channel.last_modified.into(),
0u64.into(),
]);
btree::put(&mut self.txn, &mut self.channels, &channel.name, &t8)?;

[7.13754]

[7.94488]

let sc = SerializedChannel {
graph: channel.graph.db.into(),
changes: channel.changes.db.into(),
revchanges: channel.revchanges.db.into(),
states: channel.states.db.into(),
tags: channel.tags.db.into(),
apply_counter: channel.apply_counter.into(),
last_modified: channel.last_modified.into(),
id: channel.id,
};
btree::put(&mut self.txn, &mut self.channels, &channel.name, &sc)?;
replacement in libpijul/src/pristine/sanakirja.rs at line 2170

[7.53791]→[7.13832:13907](∅→∅)

btree::del(&mut self.txn, &mut self.remotes, &remote.name, None)?;

[7.53791]

[7.94665]

btree::del(&mut self.txn, &mut self.remotes, &remote.id, None)?;
replacement in libpijul/src/pristine/sanakirja.rs at line 2173

[7.68708]→[7.94733:94780](∅→∅),[7.575536]→[7.94733:94780](∅→∅),[7.94780]→[7.575585:575616](∅→∅),[7.575585]→[7.575585:575616](∅→∅),[7.575616]→[7.94781:94807](∅→∅),[7.94807]→[7.13908:13984](∅→∅),[7.13984]→[7.575729:575741](∅→∅),[7.94945]→[7.575729:575741](∅→∅),[7.575729]→[7.575729:575741](∅→∅)

btree::put(
&mut self.txn,
&mut self.remotes,
&remote.name,
&T3([r.remote.db.into(), r.rev.db.into(), r.states.db.into()]),
)?;

[7.68708]

[7.575741]

let rr = OwnedSerializedRemote {
_remote: r.remote.db.into(),
_rev: r.rev.db.into(),
_states: r.states.db.into(),
_id_rev: r.id_rev.into(),
_path: r.path.clone(),
};
debug!("put {:?}", rr);
btree::put(&mut self.txn, &mut self.remotes, &remote.id, &rr)?;
replacement in libpijul/src/pristine/sanakirja.rs at line 2187

[7.53881]→[7.68709:68789](∅→∅)

std::mem::drop(self.open_remotes.lock().unwrap().remove(&remote.name));

[7.53881]

[7.576000]

std::mem::drop(self.open_remotes.lock().unwrap().remove(&remote.id));
replacement in libpijul/src/pristine/sanakirja.rs at line 2291

[7.97814]→[7.97814:97832](∅→∅),[7.97832]→[7.26480:26498](∅→∅)

direct_repr!(T3);
direct_repr!(T8);

[7.97813]

impl Storable for SerializedRemote {
type PageReferences = std::iter::Empty<u64>;
fn page_references(&self) -> Self::PageReferences {
std::iter::empty()
}
fn compare<T: LoadPage>(&self, _t: &T, b: &Self) -> core::cmp::Ordering {
self.cmp(b)
}
}

impl UnsizedStorable for SerializedRemote {
const ALIGN: usize = 8;

fn size(&self) -> usize {
33 + self.path.len()
}
unsafe fn onpage_size(p: *const u8) -> usize {
33 + (*p.add(32)) as usize
}
unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self {
let len = *p.add(32) as usize;
let m: &SerializedRemote =
std::mem::transmute(std::slice::from_raw_parts(p, 1 + len as usize));
m
}
unsafe fn write_to_page(&self, p: *mut u8) {
std::ptr::copy(
&self.remote as *const L64 as *const u8,
p,
33 + self.path.len(),
);
debug!(
"write_to_page: {:?}",
std::slice::from_raw_parts(p, 33 + self.path.len())
);
}
}

#[derive(Debug)]
struct OwnedSerializedRemote {
_remote: L64,
_rev: L64,
_states: L64,
_id_rev: L64,
_path: SmallString,
}

impl std::ops::Deref for OwnedSerializedRemote {
type Target = SerializedRemote;
fn deref(&self) -> &Self::Target {
let len = 33 + self._path.len() as usize;
unsafe {
std::mem::transmute(std::slice::from_raw_parts(
self as *const Self as *const u8,
len,
))
}
}
}

direct_repr!(SerializedChannel);
direct_repr!(RemoteId);
replacement in libpijul/src/pristine/mod.rs at line 113

[7.100689]→[7.100689:100751](∅→∅)

#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq)]

[7.100688]

[7.100751]

#[derive(Debug, PartialOrd, Ord, PartialEq, Eq)]
replacement in libpijul/src/pristine/mod.rs at line 115

[7.100762]→[7.100762:100787](∅→∅)

pub struct T3([L64; 3]);

[7.100762]

[7.100787]

pub struct SerializedRemote {
remote: L64,
rev: L64,
states: L64,
id_rev: L64,
path: SmallStr,
}
replacement in libpijul/src/pristine/mod.rs at line 125

[7.100861]→[7.26499:26524](∅→∅)

pub struct T8([L64; 8]);

[7.100861]

[7.100886]

pub struct SerializedChannel {
graph: L64,
changes: L64,
revchanges: L64,
states: L64,
tags: L64,
apply_counter: L64,
last_modified: L64,
id: RemoteId,
}
replacement in libpijul/src/pristine/mod.rs at line 176

[7.588131]→[7.588131:588191](∅→∅)

pub fn name(&self) -> &str {
self.name.as_str()

[7.588131]

[7.588191]

pub fn id(&self) -> &RemoteId {
&self.id
edit in libpijul/src/pristine/mod.rs at line 183

[7.588317]

[7.588419]

pub fn id_revision(&self) -> Result<u64, PoisonError> {
Ok(self.lock()?.id_rev.into())
}

pub fn set_id_revision(&self, rev: u64) -> Result<(), PoisonError> {
self.lock()?.id_rev = rev.into();
Ok(())
}
edit in libpijul/src/pristine/mod.rs at line 198

[7.588538]

[7.588538]

pub id_rev: L64,
pub path: SmallString,
replacement in libpijul/src/pristine/mod.rs at line 204

[7.69482]→[7.588660:588683](∅→∅),[7.588660]→[7.588660:588683](∅→∅)

name: SmallString,

[7.69482]

[7.588683]

id: RemoteId,
replacement in libpijul/src/pristine/mod.rs at line 211

[7.588808]→[7.588808:588845](∅→∅)

name: self.name.clone(),

[7.588808]

[7.588845]

id: self.id.clone(),
}
}
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct RemoteId(pub(crate) [u8; 16]);

impl RemoteId {
pub fn nil() -> Self {
RemoteId([0; 16])
}
pub fn from_bytes(b: &[u8]) -> Option<Self> {
if b.len() < 16 {
return None;
}
let mut x = RemoteId([0; 16]);
unsafe {
std::ptr::copy_nonoverlapping(b.as_ptr(), x.0.as_mut_ptr(), 16);
}
Some(x)
}
pub fn as_bytes(&self) -> &[u8; 16] {
&self.0
}

pub fn from_base32(b: &[u8]) -> Option<Self> {
let mut bb = RemoteId([0; 16]);
if data_encoding::BASE32_NOPAD.decode_mut(b, &mut bb.0).is_ok() {
Some(bb)
} else {
None
edit in libpijul/src/pristine/mod.rs at line 244

[7.588855]

[7.588974]

}
}

impl std::fmt::Display for RemoteId {
fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(fmt, "{}", data_encoding::BASE32_NOPAD.encode(&self.0))
edit in libpijul/src/pristine/mod.rs at line 327

[7.2520]

[7.2520]

fn id<'a>(&self, c: &'a Self::Channel) -> &'a RemoteId;
replacement in libpijul/src/pristine/mod.rs at line 571

[7.58221]→[7.27272:27309](∅→∅)

cursor!(channels, SmallStr, T8);

[7.58221]

[7.591136]

cursor!(channels, SmallStr, SerializedChannel);
replacement in libpijul/src/pristine/mod.rs at line 588

[7.592053]→[7.58608:58708](∅→∅)

fn load_remote(&self, name: &str) -> Result<Option<RemoteRef<Self>>, TxnErr<Self::GraphError>>;

[7.592053]

[7.592119]

fn load_remote(
&self,
name: &RemoteId,
) -> Result<Option<RemoteRef<Self>>, TxnErr<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 602

[7.58898]→[7.58898:58919](∅→∅)

start: &str,

[7.58898]

[7.58919]

start: &RemoteId,
replacement in libpijul/src/pristine/mod.rs at line 606

[7.605688]→[7.103127:103163](∅→∅)

cursor!(remotes, SmallStr, T3);

[7.605688]

[7.605740]

cursor!(remotes, RemoteId, SerializedRemote);
replacement in libpijul/src/pristine/mod.rs at line 639

[7.59301]→[7.59301:59321](∅→∅)

name: &str,

[7.59301]

[7.59321]

name: RemoteId,
edit in libpijul/src/pristine/mod.rs at line 665

[5.7599]

[7.37267]

}

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct SerializedPublicKey {
algorithm: crate::key::Algorithm,
key: [u8; 32],
edit in libpijul/src/pristine/mod.rs at line 967

[7.609461]

[7.44030]

// #[cfg(debug_assertions)]
pub fn debug_remotes<T: TxnT>(txn: &T) {
for t in txn.iter_remotes(&RemoteId([0; 16])).unwrap() {
let rem = t.unwrap();
debug!("{:?}", rem.id());
for x in txn.iter_remote(&rem.lock().unwrap().remote, 0).unwrap() {
debug!(" {:?}", x.unwrap());
}
}
}
replacement in libpijul/src/pristine/mod.rs at line 1564

[7.72555]→[7.72555:72639](∅→∅)

Ok(Some((name, _))) => self.txn.load_remote(name.as_str()).transpose(),

[7.72555]

[7.72639]

Ok(Some((name, _))) => self.txn.load_remote(name).transpose(),
replacement in libpijul/src/pristine/mod.rs at line 1702

[7.637990]→[7.74525:74623](∅→∅)

fn open_or_create_remote(&mut self, name: &str) -> Result<RemoteRef<Self>, Self::GraphError>;

[7.637990]

[7.638143]

fn open_or_create_remote(
&mut self,
id: RemoteId,
path: &str,
) -> Result<RemoteRef<Self>, Self::GraphError>;
replacement in libpijul/src/pristine/mod.rs at line 1723

[7.638586]→[7.74891:74976](∅→∅)

fn drop_named_remote(&mut self, remote: &str) -> Result<bool, Self::GraphError>;

[7.638586]

[5.7600]

fn drop_named_remote(&mut self, id: RemoteId) -> Result<bool, Self::GraphError>;
edit in libpijul/src/pristine/inode_metadata.rs at line 22

[7.642516]

[7.642516]

pub fn from_basename(b: &[u8]) -> Self {
use byteorder::ByteOrder;
InodeMetadata(byteorder::BigEndian::read_u16(b))
}
edit in libpijul/src/key.rs at line 1

[7.5013]

[7.5014]

use ed25519_dalek::Signer;
edit in libpijul/src/key.rs at line 5

[7.5059]→[7.5059:5104](∅→∅)

pub const CONTEXT: &'static [u8] = b"pijul";
replacement in libpijul/src/key.rs at line 9

[7.5177]→[7.5177:5230](∅→∅)

#[error("Base 32 decoding error")]
Encoding,

[7.5177]

[7.5230]

#[error("Base 58 decoding error")]
Encoding(#[from] bs58::decode::Error),
edit in libpijul/src/key.rs at line 17

[7.5404]→[7.5404:5692](∅→∅)

}

impl From<data_encoding::DecodePartial> for KeyError {
fn from(_: data_encoding::DecodePartial) -> Self {
KeyError::Encoding
}
}

impl From<data_encoding::DecodeError> for KeyError {
fn from(_: data_encoding::DecodeError) -> Self {
KeyError::Encoding
}
replacement in libpijul/src/key.rs at line 23

[7.5804]→[7.5804:5852](∅→∅)

pub expires: chrono::DateTime<chrono::Utc>,

[7.5804]

[6.3583]

#[serde(default, skip_serializing_if = "Option::is_none")]
pub expires: Option<chrono::DateTime<chrono::Utc>>,
replacement in libpijul/src/key.rs at line 33

[7.5983]→[7.5983:6031](∅→∅)

expires: chrono::DateTime<chrono::Utc>,

[7.5983]

[7.6031]

expires: Option<chrono::DateTime<chrono::Utc>>,
replacement in libpijul/src/key.rs at line 41

[7.6179]→[7.6179:6227](∅→∅)

pub expires: chrono::DateTime<chrono::Utc>,

[7.6179]

[7.6227]

#[serde(default, skip_serializing_if = "Option::is_none")]
pub expires: Option<chrono::DateTime<chrono::Utc>>,
replacement in libpijul/src/key.rs at line 50

[7.6325]→[7.6325:6373](∅→∅)

expires: chrono::DateTime<chrono::Utc>,

[7.6325]

[7.6373]

expires: Option<chrono::DateTime<chrono::Utc>>,
replacement in libpijul/src/key.rs at line 89

[7.7352]→[7.7352:7455](∅→∅)

if expires <= &chrono::Utc::now() {
return Err(KeyError::Expired);

[7.7352]

[7.7455]

if let Some(expires) = expires {
if expires <= &chrono::Utc::now() {
return Err(KeyError::Expired);
}
replacement in libpijul/src/key.rs at line 94

[7.7473]→[7.7473:7729](∅→∅)

let mut prehashed = ed25519_dalek::Sha512::new();
prehashed.update(h);
let sig = key.sign_prehashed(prehashed, Some(CONTEXT)).unwrap();
Ok(data_encoding::BASE32_NOPAD.encode(&sig.to_bytes()))

[7.7473]

[7.7729]

let sig = key.sign(&h);
Ok(bs58::encode(&sig.to_bytes()).into_string())
replacement in libpijul/src/key.rs at line 100

[7.7760]→[7.7760:7830](∅→∅)

pub fn generate(expires: chrono::DateTime<chrono::Utc>) -> Self {

[7.7760]

[7.7830]

pub fn generate(expires: Option<chrono::DateTime<chrono::Utc>>) -> Self {
replacement in libpijul/src/key.rs at line 135

[7.8970]→[7.8970:9037](∅→∅)

key: data_encoding::BASE32_NOPAD.encode(&key),

[7.8970]

[7.9037]

key: bs58::encode(&key).into_string(),
replacement in libpijul/src/key.rs at line 147

[7.9379]→[7.9379:9570](∅→∅)

let mut prehashed = ed25519_dalek::Sha512::new();
prehashed.update(&to_sign);
let sig = key.sign_prehashed(prehashed, Some(CONTEXT)).unwrap();

[7.9379]

[7.9570]

let sig = key.sign(&to_sign);
replacement in libpijul/src/key.rs at line 152

[7.9733]→[7.9733:9910](∅→∅)

key: data_encoding::BASE32_NOPAD.encode(&key.public.clone().to_bytes()),
signature: data_encoding::BASE32_NOPAD.encode(&sig.to_bytes()),

[7.9733]

[7.9910]

key: bs58::encode(&key.public.clone().to_bytes()).into_string(),
signature: bs58::encode(&sig.to_bytes()).into_string(),
replacement in libpijul/src/key.rs at line 165

[7.10241]→[7.10241:10432](∅→∅)

let mut prehashed = ed25519_dalek::Sha512::new();
prehashed.update(&to_sign);
let sig = key.sign_prehashed(prehashed, Some(CONTEXT)).unwrap();

[7.10241]

[7.10432]

let sig = key.sign(&to_sign);
replacement in libpijul/src/key.rs at line 169

[7.10555]→[7.10555:10639](∅→∅)

signature: data_encoding::BASE32_NOPAD.encode(&sig.to_bytes()),

[7.10555]

[7.10639]

signature: bs58::encode(&sig.to_bytes()).into_string(),
replacement in libpijul/src/key.rs at line 178

[7.10776]→[7.10776:10867](∅→∅)

if self.expires <= chrono::Utc::now() {
return Err(KeyError::Expired);

[7.10776]

[7.10867]

if let Some(expires) = self.expires {
if expires <= chrono::Utc::now() {
return Err(KeyError::Expired);
}
replacement in libpijul/src/key.rs at line 185

[7.10944]→[7.10944:11036](∅→∅)

let mut key_enc = data_encoding::BASE32_NOPAD.decode(self.key.as_bytes())?;

[7.10944]

[7.11036]

let mut key_enc = [0; 64];
bs58::decode(self.key.as_bytes()).into(&mut key_enc)?;
replacement in libpijul/src/key.rs at line 211

[7.11865]→[7.11865:12048](∅→∅)

let mut prehashed = ed25519_dalek::Sha512::new();
prehashed.update(&signed);
data_encoding::BASE32_NOPAD.encode(&prehashed.finalize())

[7.11865]

[7.12048]

let mut hash = ed25519_dalek::Sha512::new();
hash.update(&signed);
bs58::encode(&hash.finalize()).into_string()
replacement in libpijul/src/key.rs at line 221

[7.12197]→[7.12197:12360](∅→∅)

let key = ed25519_dalek::PublicKey::from_bytes(
&data_encoding::BASE32_NOPAD.decode(self.key.as_bytes())?,
)?;

[7.12197]

[7.12360]

let mut key = [0; 32];
bs58::decode(self.key.as_bytes()).into(&mut key)?;
let key = ed25519_dalek::PublicKey::from_bytes(&key)?;
replacement in libpijul/src/key.rs at line 225

[7.12405]→[7.12405:12526](∅→∅)

data_encoding::BASE32_NOPAD
.decode_mut(self.signature.as_bytes(), &mut signature)?;

[7.12405]

[7.12526]

bs58::decode(self.signature.as_bytes()).into(&mut signature)?;
replacement in libpijul/src/key.rs at line 228

[7.12601]→[7.12601:12630](∅→∅)

let signed =

[7.12601]

[7.12630]

let msg =
replacement in libpijul/src/key.rs at line 230

[7.12730]→[7.12730:12834](∅→∅)

debug!("signed {:?}", signed);
key.verify_strict(&signed, &signature)?;

[7.12730]

[7.12834]

key.verify_strict(&msg, &signature)?;
replacement in libpijul/src/key.rs at line 253

[7.13422]→[7.13422:13495](∅→∅)

key: data_encoding::BASE32_NOPAD.encode(key.as_bytes()),

[7.13422]

[7.13495]

key: bs58::encode(key.as_bytes()).into_string(),
replacement in libpijul/src/key.rs at line 266

[7.13755]→[7.13755:13843](∅→∅)

if expires <= date {
return Err(KeyError::Expired);

[7.13755]

[7.13843]

if let Some(expires) = expires {
if expires <= date {
return Err(KeyError::Expired);
}
replacement in libpijul/src/key.rs at line 272

[7.13900]→[7.13900:13989](∅→∅)

data_encoding::BASE32_NOPAD.decode_mut(signature.as_bytes(), &mut sig)?;

[7.13900]

[7.13989]

bs58::decode(signature.as_bytes()).into(&mut sig)?;
replacement in libpijul/src/key.rs at line 274

[7.14051]→[7.14051:14225](∅→∅)

let mut prehashed = ed25519_dalek::Sha512::new();
prehashed.update(h);
key.verify_prehashed(prehashed, Some(CONTEXT), &sig)?;

[7.14051]

[7.14225]

key.verify_strict(&h, &sig)?;
replacement in libpijul/src/key.rs at line 298

[7.14728]→[7.14728:14797](∅→∅)

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]

[7.14728]

[7.14797]

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[repr(u8)]
edit in libpijul/src/key.rs at line 304

[7.14834]

[7.14834]

impl From<u8> for Algorithm {
fn from(u: u8) -> Self {
assert_eq!(u, 0);
Algorithm::Ed25519
}
}
impl From<Algorithm> for u8 {
fn from(u: Algorithm) -> Self {
match u {
Algorithm::Ed25519 => 0,
}
}
}
replacement in libpijul/src/changestore/mod.rs at line 100

[7.2460]→[7.3985:4033](∅→∅)

debug!("filemetadata read: {:?}", buf);

[7.2460]

[6.4464]

trace!("filemetadata read: {:?}", buf);
edit in libpijul/src/changestore/mod.rs at line 105

[6.4588]→[6.4588:4626](∅→∅)

use byteorder::ByteOrder;
replacement in libpijul/src/changestore/mod.rs at line 106

[6.4653]→[6.4653:4729](∅→∅)

metadata: InodeMetadata(byteorder::BigEndian::read_u16(a)),

[6.4653]

[6.4729]

metadata: InodeMetadata::from_basename(a),
replacement in libpijul/src/changestore/mod.rs at line 117

[7.4163]→[7.4163:4216](∅→∅)

debug!("filemetadata write: {:?}", &w[l..]);

[7.4163]

[7.820132]

trace!("filemetadata write: {:?}", &w[l..]);
replacement in libpijul/src/change.rs at line 109

[7.833105]→[7.833105:833131](∅→∅)

pub struct ChangeHeader {

[7.833105]

[7.833131]

pub struct ChangeHeader_<Author> {
replacement in libpijul/src/change.rs at line 116

[6.4972]→[6.4972:5351](∅→∅),[6.5351]→[7.834123:834125](∅→∅),[7.16417]→[7.834123:834125](∅→∅),[7.834123]→[7.834123:834125](∅→∅)

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Default)]
pub struct Author {
pub name: String,
#[serde(default)]
pub full_name: Option<String>,
#[serde(default)]
pub email: Option<String>,
}

impl From<String> for Author {
fn from(name: String) -> Author {
Author {
name,
..Author::default()
}
}
}

[6.4972]

[7.834125]

/// The header of a change contains all the metadata about a change
/// (but not the actual contents of a change).
pub type ChangeHeader = ChangeHeader_<Author>;
replacement in libpijul/src/change.rs at line 132

[7.834452]→[6.5352:5383](∅→∅)

pub struct LocalChange<Hunk> {

[7.834452]

[7.834484]

pub struct LocalChange<Hunk, Author> {
replacement in libpijul/src/change.rs at line 134

[7.834510]→[6.5384:5414](∅→∅)

pub hashed: Hashed<Hunk>,

[7.834510]

[7.834541]

pub hashed: Hashed<Hunk, Author>,
replacement in libpijul/src/change.rs at line 141

[7.834670]→[6.5415:5534](∅→∅)

impl std::ops::Deref for LocalChange<Hunk<Option<Hash>, Local>> {
type Target = Hashed<Hunk<Option<Hash>, Local>>;

[7.834670]

[7.834749]

impl std::ops::Deref for LocalChange<Hunk<Option<Hash>, Local>, Author> {
type Target = Hashed<Hunk<Option<Hash>, Local>, Author>;
replacement in libpijul/src/change.rs at line 148

[7.834818]→[6.5535:5604](∅→∅)

impl std::ops::DerefMut for LocalChange<Hunk<Option<Hash>, Local>> {

[7.834818]

[7.834867]

impl std::ops::DerefMut for LocalChange<Hunk<Option<Hash>, Local>, Author> {
edit in libpijul/src/change.rs at line 153

[7.834951]

[7.834951]

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Author(pub std::collections::BTreeMap<String, String>);
replacement in libpijul/src/change.rs at line 162

[7.835040]→[6.5725:5751](∅→∅)

pub struct Hashed<Hunk> {

[7.835040]

[7.835067]

pub struct Hashed<Hunk, Author> {
replacement in libpijul/src/change.rs at line 166

[7.835181]→[7.835181:835211](∅→∅)

pub header: ChangeHeader,

[7.835181]

[7.835211]

pub header: ChangeHeader_<Author>,
replacement in libpijul/src/change.rs at line 180

[7.835735]→[6.5781:5839](∅→∅)

pub type Change = LocalChange<Hunk<Option<Hash>, Local>>;

[7.835735]

[7.835773]

pub type Change = LocalChange<Hunk<Option<Hash>, Local>, Author>;
replacement in libpijul/src/change.rs at line 1193

[7.867084]→[6.5840:5886](∅→∅)

impl LocalChange<Hunk<Option<Hash>, Local>> {

[7.867084]

[7.867109]

impl LocalChange<Hunk<Option<Hash>, Local>, Author> {
replacement in libpijul/src/change.rs at line 1340

[7.871942]→[7.871942:871982](∅→∅)

if offsets.version != VERSION {

[7.871942]

[6.6081]

if offsets.version != VERSION && offsets.version != VERSION_NOENC {
replacement in libpijul/src/change.rs at line 1353

[7.872384]→[7.872384:872440](∅→∅)

debug!("check_from_buffer, buf_ = {:?}", buf_);

[7.872384]

[7.872440]

trace!("check_from_buffer, buf_ = {:?}", buf_);
replacement in libpijul/src/change.rs at line 1366

[7.872818]→[6.6190:6276](∅→∅)

let hashed: Hashed<Hunk<Option<Hash>, Local>> = bincode::deserialize(&buf_)?;

[7.872818]

[7.872884]

let hashed: Hashed<Hunk<Option<Hash>, Local>, Author> = if offsets.version == VERSION {
bincode::deserialize(&buf_)?
} else {
let h: Hashed<noenc::Hunk<Option<Hash>, Local>, noenc::Author> =
bincode::deserialize(&buf_)?;
h.into()
};
replacement in libpijul/src/change.rs at line 1379

[7.873196]→[7.873196:873237](∅→∅)

debug!("contents = {:?}", buf_);

[7.873196]

[7.873237]

trace!("contents = {:?}", buf_);
replacement in libpijul/src/change.rs at line 1415

[7.874394]→[6.6541:6599](∅→∅)

let hashed: Hashed<Hunk<Option<Hash>, Local>> = {

[7.874394]

[7.874432]

let hashed: Hashed<Hunk<Option<Hash>, Local>, Author> = {
replacement in libpijul/src/change/text_changes.rs at line 38

[7.38731]→[6.6720:6766](∅→∅)

impl LocalChange<Hunk<Option<Hash>, Local>> {

[7.38731]

[7.38757]

impl LocalChange<Hunk<Option<Hash>, Local>, Author> {
replacement in libpijul/src/change/text_changes.rs at line 111

[7.41262]→[7.41262:41376](∅→∅)

w.write_all(toml::ser::to_string_pretty(&self.header)?.as_bytes())?;
w.write_all(b"\n")?;

[7.41262]

[7.41376]

let s = toml::ser::to_string_pretty(&self.header)?;
writeln!(w, "{}", s)?;
edit in libpijul/src/change/noenc.rs at line 61

[6.8121]

[6.8121]

let encoding = Some(crate::text_encoding::Encoding(encoding_rs::UTF_8));
replacement in libpijul/src/change/noenc.rs at line 72

[6.8436]→[6.8436:8468](∅→∅)

encoding: None,

[6.8436]

[6.8468]

encoding,
replacement in libpijul/src/change/noenc.rs at line 82

[6.8697]→[6.8697:8729](∅→∅)

encoding: None,

[6.8697]

[6.8729]

encoding,
replacement in libpijul/src/change/noenc.rs at line 94

[6.9014]→[6.9014:9046](∅→∅)

encoding: None,

[6.9014]

[6.9046]

encoding,
replacement in libpijul/src/change/noenc.rs at line 103

[6.9409]→[6.9409:9441](∅→∅)

encoding: None,

[6.9409]

[6.9441]

encoding,
replacement in libpijul/src/change/noenc.rs at line 113

[6.9684]→[6.9684:9716](∅→∅)

encoding: None,

[6.9684]

[6.9716]

encoding,
replacement in libpijul/src/change/noenc.rs at line 124

[6.10150]→[6.10150:10182](∅→∅)

encoding: None,

[6.10150]

[6.10182]

encoding,
edit in libpijul/src/change/noenc.rs at line 139

[6.10511]→[6.10511:10554](∅→∅)

debug!("offsets = {:?}", offsets);
replacement in libpijul/src/change/noenc.rs at line 142

[6.10675]→[6.10675:10733](∅→∅)

let hashed: Hashed<Hunk<Option<Hash>, Local>> = {

[6.10675]

[6.10733]

let hashed: Hashed<Hunk<Option<Hash>, Local>, Author> = {
replacement in libpijul/src/change/noenc.rs at line 170

[6.11856]→[6.11856:11901](∅→∅)

debug!("unhashed = {:?}", unhashed);

[6.11856]

[6.11901]

trace!("unhashed = {:?}", unhashed);
replacement in libpijul/src/change/noenc.rs at line 182

[6.12318]→[6.12318:12363](∅→∅)

debug!("contents = {:?}", contents);

[6.12318]

[6.12363]

trace!("contents = {:?}", contents);
replacement in libpijul/src/change/noenc.rs at line 193

[6.12509]→[6.12509:12666](∅→∅)

impl From<Hashed<Hunk<Option<Hash>, Local>>> for Hashed<super::Hunk<Option<Hash>, Local>> {
fn from(hashed: Hashed<Hunk<Option<Hash>, Local>>) -> Self {

[6.12509]

[6.12666]

impl From<Hashed<Hunk<Option<Hash>, Local>, Author>>
for Hashed<super::Hunk<Option<Hash>, Local>, super::Author>
{
fn from(hashed: Hashed<Hunk<Option<Hash>, Local>, Author>) -> Self {
replacement in libpijul/src/change/noenc.rs at line 201

[6.12824]→[6.12824:12859](∅→∅)

header: hashed.header,

[6.12824]

[6.12859]

header: hashed.header.into(),
edit in libpijul/src/change/noenc.rs at line 208

[6.13030]

use super::ChangeHeader_;

impl From<ChangeHeader_<Author>> for ChangeHeader_<super::Author> {
fn from(c: ChangeHeader_<Author>) -> Self {
ChangeHeader_ {
message: c.message,
description: c.description,
timestamp: c.timestamp,
authors: c.authors.into_iter().map(|x| x.into()).collect(),
}
}
}

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Default)]
pub struct Author {
pub name: String,
#[serde(default)]
pub full_name: Option<String>,
#[serde(default)]
pub email: Option<String>,
}

impl From<String> for Author {
fn from(name: String) -> Author {
Author {
name,
..Author::default()
}
}
}

impl From<Author> for super::Author {
fn from(c: Author) -> Self {
let mut b = std::collections::BTreeMap::new();
b.insert("name".to_string(), c.name);
if let Some(n) = c.full_name {
b.insert("full_name".to_string(), n);
}
if let Some(n) = c.email {
b.insert("email".to_string(), n);
}
super::Author(b)
}
}
replacement in libpijul/src/change/change_file.rs at line 7

[7.90296]→[6.13031:13078](∅→∅)

hashed: Hashed<Hunk<Option<Hash>, Local>>,

[7.90296]

[7.90323]

hashed: Hashed<Hunk<Option<Hash>, Local>, Author>,
replacement in libpijul/src/change/change_file.rs at line 56

[7.91638]→[6.13264:13352](∅→∅)

let hashed: Hashed<Hunk<Option<Hash>, Local>> = if offsets.version == VERSION {

[7.91638]

[7.91676]

let hashed: Hashed<Hunk<Option<Hash>, Local>, Author> = if offsets.version == VERSION {
replacement in libpijul/src/change/change_file.rs at line 59

[7.91783]→[6.13353:13421](∅→∅)

debug!("deserialize current version {:?}", buf2.len());

[7.91783]

[7.91783]

trace!("deserialize current version {:?}", buf2.len());
replacement in libpijul/src/change/change_file.rs at line 65

[6.13602]→[6.13602:13752](∅→∅)

debug!("deserialize noenc {:?}", buf2.len());
let h: Hashed<noenc::Hunk<Option<Hash>, Local>> = bincode::deserialize(&buf2)?;

[6.13602]

[6.13752]

trace!("deserialize noenc {:?}", buf2.len());
let h: Hashed<noenc::Hunk<Option<Hash>, Local>, noenc::Author> =
bincode::deserialize(&buf2)?;
replacement in libpijul/src/change/change_file.rs at line 79

[7.92195]→[6.13774:13848](∅→∅)

debug!("parsing unhashed: {:?}", std::str::from_utf8(&buf2));

[7.92195]

[6.13848]

trace!("parsing unhashed: {:?}", std::str::from_utf8(&buf2));
replacement in libpijul/src/change/change_file.rs at line 108

[7.92990]→[7.92990:93052](∅→∅)

debug!("read_contents {:?} {:?}", offset, buf.len());

[7.92990]

[7.93052]

trace!("read_contents {:?} {:?}", offset, buf.len());
replacement in libpijul/src/change/change_file.rs at line 116

[7.93237]→[6.13896:13961](∅→∅)

pub fn hashed(&self) -> &Hashed<Hunk<Option<Hash>, Local>> {

[7.93237]

[7.93282]

pub fn hashed(&self) -> &Hashed<Hunk<Option<Hash>, Local>, Author> {
edit in libpijul/Cargo.toml at line 140

[7.16894]

[7.109305]

bs58 = "0.4"
edit in Cargo.lock at line 3

[7.1030477]

[7.1030477]

version = 3
replacement in Cargo.lock at line 7

[7.1030508]→[7.2333:2352](∅→∅)

version = "0.15.1"

[7.1030508]

[7.1030527]

version = "0.15.2"
replacement in Cargo.lock at line 9

[7.1030592]→[7.2353:2431](∅→∅)

checksum = "03345e98af8f3d786b6d9f656ccfa6ac316d954e92bc4841f0bba20789d5fb5a"

[7.1030592]

[7.1030670]

checksum = "e7a2e47a1fbe209ee101dd6d61285226744c6c8d3c21c8dc878ba6cb9f467f3a"
replacement in Cargo.lock at line 44

[7.1031374]→[7.0:19](∅→∅)

version = "1.0.40"

[7.1031374]

[7.1031393]

version = "1.0.41"
replacement in Cargo.lock at line 46

[7.1031458]→[7.20:98](∅→∅)

checksum = "28b2cd92db5cbd74e8e5028f7e27dd7aa3090e89e4f2a197cc7c8dfb69c7063b"

[7.1031458]

[7.1031536]

checksum = "15af2628f6890fe2609a3b91bef4c83450512802e59489f9c1cb1fa5df064a61"
replacement in Cargo.lock at line 79

[7.1032392]→[7.2531:2550](∅→∅)

version = "0.3.59"

[7.1032392]

[7.1032411]

version = "0.3.60"
replacement in Cargo.lock at line 81

[7.1032476]→[7.2551:2629](∅→∅)

checksum = "4717cfcbfaa661a0fd48f8453951837ae7e8f81e481fbb136e3202d72805a744"

[7.1032476]

[7.1032554]

checksum = "b7815ea54e4d821e791162e078acbebfd6d8c8939cd559c9335dceb1c8ca7282"
edit in Cargo.lock at line 142

[7.1034471]

[7.1034471]

[[package]]
name = "bs58"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3"
replacement in Cargo.lock at line 205

[7.5974]→[7.2836:2855](∅→∅)

version = "0.1.12"

[7.5974]

[7.5993]

version = "0.1.13"
replacement in Cargo.lock at line 207

[7.6058]→[7.2856:2934](∅→∅)

checksum = "459978032e1aa8d5ca411ee0057ea84f98a93a648ff9f78654e53f33447cf0f9"

[7.6058]

[7.6136]

checksum = "81a81b0d8f8ee23417182818b4f06312c5f535c2b04eef1773f7c24bbdf8c500"
replacement in Cargo.lock at line 302

[7.18250]→[7.18250:18268](∅→∅)

version = "0.1.4"

[7.18250]

[7.18268]

version = "0.1.5"
replacement in Cargo.lock at line 304

[7.18333]→[7.18333:18411](∅→∅)

checksum = "ed00c67cb5d0a7d64a44f6ad2668db7e7530311dd53ea79bcd4fb022c64911c8"

[7.18333]

[7.18411]

checksum = "66c99696f6c9dd7f35d486b9d04d7e6e202aa3e8c40d553f2fdf5e7e0c6a71ef"
replacement in Cargo.lock at line 529

[7.1042254]→[7.152237:152255](∅→∅)

version = "0.8.3"

[7.1042254]

[7.1042546]

version = "0.8.4"
replacement in Cargo.lock at line 531

[7.1042611]→[7.152256:152334](∅→∅)

checksum = "17392a012ea30ef05a610aa97dfb49496e71c9f676b27879922ea5bdf60d9d3f"

[7.1042611]

[7.1042689]

checksum = "a19187fea3ac7e84da7dacf48de0c45d63c6a76f9490dae389aead16c243fce3"
replacement in Cargo.lock at line 569

[7.1043005]→[7.19657:19681](∅→∅)

"redox_syscall 0.2.8",

[7.1043005]

[7.827]

"redox_syscall 0.2.9",
replacement in Cargo.lock at line 793

[7.1048466]→[7.1048466:1048484](∅→∅)

version = "0.4.6"

[7.1048466]

[7.1048484]

version = "0.4.8"
replacement in Cargo.lock at line 795

[7.1048549]→[7.1048549:1048627](∅→∅)

checksum = "c152169ef1e421390738366d2f796655fec62621dabbd0fd476f905934061e4a"

[7.1048549]

[7.1048627]

checksum = "10463d9ff00a2a068db14231982f5132edebad0d7660cd956a1c30292dbcbfbd"
replacement in Cargo.lock at line 831

[7.1049280]→[7.11084:11102](∅→∅)

version = "0.3.2"

[7.1049280]

[7.1049298]

version = "0.3.3"
replacement in Cargo.lock at line 833

[7.1049363]→[7.11103:11181](∅→∅)

checksum = "87cbf45460356b7deeb5e3415b5563308c0a9b057c85e12b06ad551f98d0a6ac"

[7.1049363]

[7.1049441]

checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c"
replacement in Cargo.lock at line 840

[7.1049518]→[7.154050:154069](∅→∅)

version = "0.1.18"

[7.1049518]

[7.1049537]

version = "0.1.19"
replacement in Cargo.lock at line 842

[7.1049602]→[7.154070:154148](∅→∅)

checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c"

[7.1049602]

[7.1049680]

checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
replacement in Cargo.lock at line 914

[7.1051305]→[7.21276:21295](∅→∅)

version = "0.14.8"

[7.1051305]

[7.1051324]

version = "0.14.9"
replacement in Cargo.lock at line 916

[7.1051389]→[7.21296:21374](∅→∅)

checksum = "d3f71a7eea53a3f8257a7b4795373ff886397178cd634430ea94e12d7fe4fe34"

[7.1051389]

[7.1051467]

checksum = "07d6baa1b441335f3ce5098ac421fb6547c46dda735ca1bc6d0153c838f9dd83"
replacement in Cargo.lock at line 928

[7.1051613]→[7.154346:154362](∅→∅)

"pin-project",

[7.1051613]

[7.1051635]

"pin-project-lite",
replacement in Cargo.lock at line 962

[7.1052260]→[7.1123:1142](∅→∅)

version = "0.4.17"

[7.1052260]

[7.1052279]

version = "0.4.18"
replacement in Cargo.lock at line 964

[7.1052344]→[7.1143:1221](∅→∅)

checksum = "b287fb45c60bb826a0dc68ff08742b9d88a2fea13d6e0c286b3172065aaf878c"

[7.1052344]

[7.1052422]

checksum = "713f1b139373f96a2e0ce3ac931cd01ee973c3c5dd7c40c0c2efe96ad2b6751d"
replacement in Cargo.lock at line 999

[7.1053286]→[7.1053286:1053304](∅→∅)

version = "2.3.0"

[7.1053286]

[7.1053304]

version = "2.3.1"
replacement in Cargo.lock at line 1001

[7.1053369]→[7.1053369:1053447](∅→∅)

checksum = "47be2f14c678be2fdcab04ab1171db51b2762ce6f0a8ee87c8dd4a04ed216135"

[7.1053369]

[7.1053447]

checksum = "68f2d64f2edebec4ce84ad108148e67e1064789bee435edc5b60ad398714a3a9"
replacement in Cargo.lock at line 1035

[7.1054747]→[7.21393:21412](∅→∅)

version = "0.2.95"

[7.1054747]

[7.1054766]

version = "0.2.97"
replacement in Cargo.lock at line 1037

[7.1054831]→[7.21413:21491](∅→∅)

checksum = "789da6d93f1b866ffe175afc5322a4d76c038605a1c3319bb57b06967ca98a36"

[7.1054831]

[7.1054909]

checksum = "12b8adadd720df158f4d70dfe7ccc6adb0472d7c55ca83445f6a5ab3e36f8fb6"
edit in Cargo.lock at line 1062

[104.793]

[104.793]

"bs58",
replacement in Cargo.lock at line 1086

[7.21681]→[7.21681:21701](∅→∅)

"rand_core 0.6.2",

[7.21681]

[7.1055756]

"rand_core 0.6.3",
replacement in Cargo.lock at line 1105

[7.1055917]→[7.1055917:1055935](∅→∅)

version = "0.2.6"

[7.1055917]

[7.1055935]

version = "0.2.7"
replacement in Cargo.lock at line 1107

[7.1056000]→[7.1056000:1056078](∅→∅)

checksum = "a685b64f837b339074115f2e7f7b431ac73681d08d75b389db7498b8892b8a58"

[7.1056000]

[7.1056078]

checksum = "6b779387cd56adfbc02ea4a668e704f729be8d6a6abd2c27ca5ee537849a92fd"
edit in Cargo.lock at line 1112

[7.1056126]

[7.1056126]

"walkdir",
replacement in Cargo.lock at line 1241

[7.2460]→[7.3203:3222](∅→∅)

version = "0.7.11"

[7.2460]

[7.1059225]

version = "0.7.13"
replacement in Cargo.lock at line 1243

[7.1059290]→[7.3223:3301](∅→∅)

checksum = "cf80d3e903b34e0bd7282b218398aec54e082c840d9baf8339e0080a0c542956"

[7.1059290]

[7.1059368]

checksum = "8c2bdb6314ec10835cd3293dd268473a835c02b7b352e788be788b3c6ca6bb16"
replacement in Cargo.lock at line 1351

[7.1061523]→[7.4378:4397](∅→∅)

version = "0.24.0"

[7.1061523]

[7.1061542]

version = "0.25.3"
replacement in Cargo.lock at line 1353

[7.1061607]→[7.4398:4476](∅→∅)

checksum = "1a5b3dd1c072ee7963717671d1ca129f1048fda25edea6b752bfc71ac8854170"

[7.1061607]

[7.1061685]

checksum = "a38f2be3697a57b4060074ff41b44c16870d916ad7877c17696e063257482bc7"
dependencies = [
"memchr 2.4.0",
]
replacement in Cargo.lock at line 1360

[7.1061717]→[7.3400:3418](∅→∅)

version = "1.7.2"

[7.1061717]

[7.1061735]

version = "1.8.0"
replacement in Cargo.lock at line 1362

[7.1061800]→[7.1236:1314](∅→∅)

checksum = "af8b08b04175473088b46763e51ee54da5f9a164bc162f615b91bc179dbf15a3"

[7.1061800]

[7.1061878]

checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"
replacement in Cargo.lock at line 1372

[7.1061908]→[7.4479:4499](∅→∅)

version = "0.10.34"

[7.1061908]

[7.1061928]

version = "0.10.35"
replacement in Cargo.lock at line 1374

[7.1061993]→[7.4500:4578](∅→∅)

checksum = "6d7830286ad6a3973c0f1d9b73738f69c76b739301d0229c4b96501695cbe4c8"

[7.1061993]

[7.1062071]

checksum = "549430950c79ae24e6d02e0b7404534ecf311d94cc9f861e9e4020187d13d885"
replacement in Cargo.lock at line 1392

[7.1062411]→[7.4579:4598](∅→∅)

version = "0.9.63"

[7.1062411]

[7.1062430]

version = "0.9.65"
replacement in Cargo.lock at line 1394

[7.1062495]→[7.4599:4677](∅→∅)

checksum = "b6b0d6fb7d80f877617dfcb014e605e2b5ab2fb0afdf27935219bb6bd984cb98"

[7.1062495]

[7.1062573]

checksum = "7a7907e3bfa08bb85105209cdfcb6c63d109f8f6c1ed6ca318fff5c1853fbc1d"
replacement in Cargo.lock at line 1472

[7.1063591]→[7.23511:23535](∅→∅)

"redox_syscall 0.2.8",

[7.1063591]

[7.1063609]

"redox_syscall 0.2.9",
replacement in Cargo.lock at line 1535

[7.1969]→[7.118314:118329](∅→∅),[7.1067]→[7.118314:118329](∅→∅)

"rand 0.8.3",

[7.1969]

[7.1064359]

"rand 0.8.4",
edit in Cargo.lock at line 1565

[7.1064668]→[7.1064668:1064689](∅→∅),[7.1064689]→[7.3737:3755](∅→∅),[7.3755]→[7.1065209:1065274](∅→∅),[7.155787]→[7.1065209:1065274](∅→∅),[7.1065209]→[7.1065209:1065274](∅→∅),[7.1065274]→[7.3756:3834](∅→∅),[7.3834]→[7.1065352:1065369](∅→∅),[7.155866]→[7.1065352:1065369](∅→∅),[7.1065352]→[7.1065352:1065369](∅→∅),[7.1065369]→[7.155867:155892](∅→∅),[7.155892]→[7.1065403:1065448](∅→∅),[7.1065403]→[7.1065403:1065448](∅→∅),[7.1065448]→[7.3835:3853](∅→∅),[7.312]→[7.1065466:1065531](∅→∅),[7.1252]→[7.1065466:1065531](∅→∅),[7.2055]→[7.1065466:1065531](∅→∅),[7.3853]→[7.1065466:1065531](∅→∅),[7.155911]→[7.1065466:1065531](∅→∅),[7.1065466]→[7.1065466:1065531](∅→∅),[7.1065531]→[7.3854:3932](∅→∅),[7.391]→[7.1065609:1065675](∅→∅),[7.1331]→[7.1065609:1065675](∅→∅),[7.2134]→[7.1065609:1065675](∅→∅),[7.3932]→[7.1065609:1065675](∅→∅),[7.155990]→[7.1065609:1065675](∅→∅),[7.1065609]→[7.1065609:1065675](∅→∅)

name = "pin-project"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c7509cc106041c40a4518d2af7a61530e1eed0e6285296a3d8c5472806ccc4a4"
dependencies = [
"pin-project-internal",
]

[[package]]
name = "pin-project-internal"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "48c950132583b500556b1efd71d45b319029f2b71518d979fcc208e16b42426f"
dependencies = [
"proc-macro2",
"quote",
"syn",
]

[[package]]
replacement in Cargo.lock at line 1566

[7.1065701]→[7.3933:3951](∅→∅)

version = "0.2.6"

[7.1065701]

[7.1392]

version = "0.2.7"
replacement in Cargo.lock at line 1568

[7.1457]→[7.3952:4030](∅→∅)

checksum = "dc0e1f259c92177c30a4c9d177246edd0a3568b25756a977d0632cf8fa37e905"

[7.1457]

[7.1535]

checksum = "8d31d11c69a6b52a174b42bdc0c30e5e11670f90788b2c471c31c1d17d449443"
replacement in Cargo.lock at line 1670

[7.118627]→[7.156089:156107](∅→∅),[7.1068089]→[7.156089:156107](∅→∅)

version = "0.8.3"

[7.118627]

[7.1068107]

version = "0.8.4"
replacement in Cargo.lock at line 1672

[7.1068172]→[7.156108:156186](∅→∅)

checksum = "0ef9e7e66b4468674bfcb0c81af8b7fa0bb154fa9f28eb840da5c447baeb8d7e"

[7.1068172]

[7.1068250]

checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
replacement in Cargo.lock at line 1675

[7.1068290]→[7.118628:118650](∅→∅),[7.118650]→[7.156187:156207](∅→∅),[7.9247]→[7.156187:156207](∅→∅),[7.156207]→[7.118651:118669](∅→∅)

"rand_chacha 0.3.0",
"rand_core 0.6.2",
"rand_hc 0.3.0",

[7.1068290]

[7.118669]

"rand_chacha 0.3.1",
"rand_core 0.6.3",
"rand_hc 0.3.1",
replacement in Cargo.lock at line 1692

[7.907]→[7.907:925](∅→∅)

version = "0.3.0"

[7.1068368]

[7.925]

version = "0.3.1"
replacement in Cargo.lock at line 1694

[7.990]→[7.990:1068](∅→∅)

checksum = "e12735cf05c9e10bf21534da50a147b924d555dc7a547c42e6bb2d5b6017ae0d"

[7.990]

[7.1068]

checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
replacement in Cargo.lock at line 1697

[7.1100]→[7.156208:156228](∅→∅)

"rand_core 0.6.2",

[7.1100]

[7.1068575]

"rand_core 0.6.3",
replacement in Cargo.lock at line 1726

[7.1162]→[7.156229:156247](∅→∅)

version = "0.6.2"

[7.1162]

[7.1180]

version = "0.6.3"
replacement in Cargo.lock at line 1728

[7.1245]→[7.156248:156326](∅→∅)

checksum = "34cf66eb183df1c5876e2dcf6b13d57340741e8dc255b48e40a26de954d06ae7"

[7.1245]

[7.1323]

checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
replacement in Cargo.lock at line 1744

[7.119149]→[7.1428:1446](∅→∅),[7.1428]→[7.1428:1446](∅→∅)

version = "0.3.0"

[7.119149]

[7.1446]

version = "0.3.1"
replacement in Cargo.lock at line 1746

[7.1511]→[7.1511:1589](∅→∅)

checksum = "3190ef7066a446f2e7f42e239d161e905420ccab01eb967c9eb27d21b2322a73"

[7.1511]

[7.1589]

checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
replacement in Cargo.lock at line 1748

[7.1606]→[7.156348:156368](∅→∅)

"rand_core 0.6.2",

[7.1606]

[7.1069025]

"rand_core 0.6.3",
replacement in Cargo.lock at line 1759

[7.24714]→[7.4701:4719](∅→∅),[7.1069063]→[7.4701:4719](∅→∅)

version = "0.2.8"

[7.24714]

[7.1069082]

version = "0.2.9"
replacement in Cargo.lock at line 1761

[7.1069147]→[7.4720:4798](∅→∅)

checksum = "742739e41cd49414de871ea5e549afb7e2a3ac77b589bcbebe8c82fab37147fc"

[7.1069147]

[7.2417]

checksum = "5ab49abadf3f9e1c4bc499e8845e152ad87d2ad2d30371841171169e9d75feee"
replacement in Cargo.lock at line 1773

[7.24735]→[7.24735:24759](∅→∅)

"redox_syscall 0.2.8",

[7.24735]

[7.2732]

"redox_syscall 0.2.9",
replacement in Cargo.lock at line 1804

[7.1070218]→[7.4450:4469](∅→∅)

version = "0.11.3"

[7.1070218]

[7.1070237]

version = "0.11.4"
replacement in Cargo.lock at line 1806

[7.1070302]→[7.4470:4548](∅→∅)

checksum = "2296f2fac53979e8ccbc4a1136b25dcefd37be9ed7e4a1f6b05a6029c84ff124"

[7.1070302]

[7.1070380]

checksum = "246e9f61b9bb77df069a947682be06e31ac43ea37862e244a69f177694ea6d22"
edit in Cargo.lock at line 1826

[7.1070651]

[7.1070651]

"serde_json",
replacement in Cargo.lock at line 1849

[7.1071329]→[7.5015:5034](∅→∅)

version = "0.1.19"

[7.1071329]

[7.1071348]

version = "0.1.20"
replacement in Cargo.lock at line 1851

[7.1071413]→[7.5035:5113](∅→∅)

checksum = "410f7acf3cb3a44527c5d9546bad4bf4e6c460915d5f9f2fc524498bfe8f70ce"

[7.1071413]

[7.156891]

checksum = "dead70b0b5e03e9c814bcb6b01e03e68f7c57a80aa48c72ec92152ab3e818d49"
replacement in Cargo.lock at line 1870

[7.1072132]→[5.7743:7761](∅→∅)

version = "1.2.4"

[7.1072132]

[7.1072151]

version = "1.2.5"
replacement in Cargo.lock at line 1872

[7.1072216]→[5.7762:7840](∅→∅)

checksum = "0bbeaf95d57d98d57cc2f7f58bc0028e2e5a49e446bedb0288ed755238b60c32"

[7.1072216]

[7.1072294]

checksum = "5503ef92c94be580857160eb38b30d4f662a718ef89cdd59798fbab0e4450835"
replacement in Cargo.lock at line 1911

[7.1072854]→[7.4549:4567](∅→∅)

version = "2.2.0"

[7.1072854]

[7.1072872]

version = "2.3.1"
replacement in Cargo.lock at line 1913

[7.1072937]→[7.4568:4646](∅→∅)

checksum = "3670b1d2fdf6084d192bc71ead7aabe6c06aa2ea3fbd9cc3ac111fa5c2b1bd84"

[7.1072937]

[7.1073015]

checksum = "23a2ac85147a3a11d77ecf1bc7166ec0b92febfa4461c37944e180f319ece467"
replacement in Cargo.lock at line 1924

[7.1073172]→[7.4647:4665](∅→∅)

version = "2.2.0"

[7.1073172]

[7.1073190]

version = "2.3.0"
replacement in Cargo.lock at line 1926

[7.1073255]→[7.4666:4744](∅→∅)

checksum = "3676258fd3cfe2c9a0ec99ce3038798d847ce3e4bb17746373eb9f0f1ac16339"

[7.1073255]

[7.1073333]

checksum = "7e4effb91b4b8b6fb7732e670b6cee160278ff8e6bf485c7805d9e319d76e284"
replacement in Cargo.lock at line 2054

[7.1075798]→[7.5214:5233](∅→∅)

version = "1.0.72"

[7.1075798]

[7.1075817]

version = "1.0.73"
replacement in Cargo.lock at line 2056

[7.1075882]→[7.5234:5312](∅→∅)

checksum = "a1e8cdbefb79a9a5a65e0db8b47b723ee907b7c7f8496c76a1770b5c310bab82"

[7.1075882]

[7.1075960]

checksum = "f71489ff30030d2ae598524f61326b902466f72a0fb1a8564c001cc63425bcc7"
replacement in Cargo.lock at line 2094

[7.1076514]→[7.119548:119563](∅→∅),[7.119563]→[7.25997:26021](∅→∅)

"rand 0.8.3",
"redox_syscall 0.2.8",

[7.1076514]

[7.1076541]

"rand 0.8.4",
"redox_syscall 0.2.9",
replacement in Cargo.lock at line 2263

[7.1080033]→[7.26518:26536](∅→∅)

version = "1.6.1"

[7.1080033]

[7.4153]

version = "1.7.1"
replacement in Cargo.lock at line 2265

[7.4218]→[7.26537:26615](∅→∅)

checksum = "0a38d31d7831c6ed7aad00aa4c12d9375fd225a6dd77da1d25b707346319a975"

[7.4218]

[7.4296]

checksum = "5fb2ed024293bb19f7a5dc54fe83bf86532a44c12a2bb8ba40d64a4509395ca2"
replacement in Cargo.lock at line 2397

[7.1083214]→[7.26972:26991](∅→∅)

version = "0.1.18"

[7.1083214]

[7.1083233]

version = "0.1.19"
replacement in Cargo.lock at line 2399

[7.1083298]→[7.26992:27070](∅→∅)

checksum = "33717dca7ac877f497014e10d73f3acf948c342bee31b5ca7892faf94ccc6b49"

[7.1083298]

[7.1083376]

checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
replacement in Cargo.lock at line 2445

[7.1084515]→[7.27092:27111](∅→∅)

version = "0.2.13"

[7.1084515]

[7.1084534]

version = "0.2.15"
replacement in Cargo.lock at line 2447

[7.1084599]→[7.27112:27190](∅→∅)

checksum = "025ce40a007e1907e58d5bc1a594def78e5573bb0b1160bc389634e8f12e4faa"

[7.1084599]

[7.1084677]

checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"