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

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

    pub async fn find_root_with_dot_dir(

    pub fn find_root_with_dot_dir(

    )
        .unwrap();
    static ref ADDRESS_NOPATH: Regex = Regex::new(
        r#"(ssh://)?((?P<user>[^@]+)@)?((?P<host>(\[([^\]]+)\])|([^:/]+)))(:(?P<port>\d+))?"#

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

pub fn ssh_remote(addr: &str, with_path: bool) -> Option<Remote> {
    let cap = if with_path {
        ADDRESS.captures(addr)?
    } else {
        ADDRESS_NOPATH.captures(addr)?
    };

    let path = {

    let path = if with_path {

    } else {
        ""

    Id {
        sender: Option<tokio::sync::oneshot::Sender<Option<libpijul::pristine::RemoteId>>>,
    },

    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>,
    },

        session: thrussh::client::Session,

        mut session: thrussh::client::Session,

                        } 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(());

                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);
                    }
                }

    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?)
    }

    }
    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)

        with_path: bool,

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

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

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

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

    with_path: bool,

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

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

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

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

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

        let id = if let Some(id) = self.get_id(txn).await? {
            id

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

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

                } 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())))

    }
    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)

        remote: &RemoteRef<T>,

        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?)?;

        let id = self.get_id(txn).await?.unwrap();

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

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

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

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

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

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

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

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

    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)
        }
    }

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

            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()))?;
                }

            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()))?;

    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)
    }

    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))
    }

    }
    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)

        log::debug!("{:?}", e);

    pub key_path: String,
    pub short_name: String,

    pub key_path: Option<String>,
    pub name: String,

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

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

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

            let (s, meta) = std::fs::read(&dir)
                .and_then(|x| Ok((x, std::fs::metadata(&dir)?)))

                        std::fs::read(&dir)

                        std::fs::read(&dir).and_then(|x| Ok((x, std::fs::metadata(&dir)?)))

                        std::fs::read(&dir)

                        std::fs::read(&dir).and_then(|x| Ok((x, std::fs::metadata(&dir)?)))

                Ok(t)

                let ts = meta
                    .modified()?
                    .duration_since(std::time::SystemTime::UNIX_EPOCH)
                    .unwrap()
                    .as_secs();
                Ok((t, ts))

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

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

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

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

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

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

    use libpijul::change::Author;
    let mut b = std::collections::BTreeMap::new();

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

        b.insert("name".to_string(), a.to_string());

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

            b.insert("key".to_string(), k.key);
        } else {
            bail!("No identity configured yet. Please use `pijul key` to create one")

    authors.push(Author(b));

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

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

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

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

        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")
        };

        let key = super::load_key()?;

                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)?;

        let mut b = std::collections::BTreeMap::new();

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

            b.insert("name".to_string(), a.clone());

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

                b.insert("key".to_string(), k.key);

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

        authors.push(Author(b));
        let templates = config
            .as_ref()
            .ok()
            .and_then(|(cfg, _)| cfg.template.as_ref());

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

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

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

                for r in txn.iter_remotes(&libpijul::pristine::RemoteId::nil())? {

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

                    writeln!(stdout, "  {}: {}", r.id(), r.lock().unwrap().path.as_str())?;

                let remote =
                    if let Some(r) = libpijul::pristine::RemoteId::from_base32(remote.as_bytes()) {
                        r
                    } else {
                        bail!("Could not parse identifier: {:?}", remote)
                    };

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

                if !txn.drop_named_remote(remote)? {
                    bail!("Remote not found: {:?}", remote)

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

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

                true,

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

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

                true,

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

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

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

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

                &remote_changes.as_ref().unwrap().1,

    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();

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

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

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

            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) {

            } 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()?;

use anyhow::bail;

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

            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()
            }

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

    pub public_key: libpijul::key::PublicKey,
    pub login: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,

    origin: String,

    pub origin: String,

    email: Option<String>,

    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")
    }

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

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

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

            let mut id_path = repo.path.join(libpijul::DOT_DIR);
            id_path.push("identities");

                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) {

                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) {

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

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

                    } else {
                        auth.0.get("name").unwrap()

use crate::repository::Repository;

use chrono::Datelike;

        name: String,

        login: String,
    },
    Prove {
        #[clap(short = 'k')]
        no_cert_check: bool,
        remote: String,

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

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

                    let expires = chrono::Utc::now();
                    let expires = expires.with_year(expires.year() + 1).unwrap();

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

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

                            name,

                            login,

                            name: None,
                            last_modified: std::time::SystemTime::now()
                                .duration_since(std::time::SystemTime::UNIX_EPOCH)
                                .unwrap()
                                .as_secs(),

            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?;
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            libpijul::pristine::debug_remotes(&txn);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                true,

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

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

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

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

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

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

            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
            },

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

    channels: UDb<SmallStr, SerializedChannel>,
    remotes: UDb<RemoteId, SerializedRemote>,

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

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

direct_repr!(SerializedPublicKey);

            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());

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

                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());

                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());

            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());

            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());

    pub id: RemoteId,

    }
    fn id<'a>(&self, c: &'a Self::Channel) -> &'a RemoteId {
        &c.id

                    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(),

                    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,

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

    fn load_remote(
        &self,
        name: &RemoteId,
    ) -> Result<Option<RemoteRef<Self>>, TxnErr<Self::GraphError>> {
        let name = name.to_owned();

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

                Some((name_, remote)) if name == *name_ => {

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

                        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(),

                        name: name.clone(),

                        id: name,

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

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

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

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

        start: &str,

        start: &RemoteId,

        let name = SmallString::from_str(start);

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

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

        name: &str,

        name: RemoteId,

        let name = SmallString::from_str(name);

        let name = name.to_owned();

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

                Some((name_, remote)) if *name_ == name => {

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

                            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(),

                        name: name.clone(),

                        id: name,

                            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(),

                            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,

                                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
                                },

                        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
                        },

                    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()),

                    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()),

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

    fn open_or_create_remote(
        &mut self,
        id: RemoteId,
        path: &str,
    ) -> Result<RemoteRef<Self>, Self::GraphError> {

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

        match self.open_remotes.lock().unwrap().entry(id) {

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

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

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

                            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),

                        name: name.clone(),

                        id,

                                id_rev: 0u64.into(),
                                path: SmallString::from_str(path),

                            name: name.clone(),

                            id,

        Ok(self

        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

            .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();

            .remove(&remote.id)
            .unwrap();

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

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

    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) {

    fn drop_named_remote(&mut self, id: RemoteId) -> Result<bool, Self::GraphError> {
        if let Some(r) = self.open_remotes.lock().unwrap().remove(&id) {

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

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

                    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(),

                    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,

        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)?;

        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)?;

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

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

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

        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)?;

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

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

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

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);

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

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

pub struct T3([L64; 3]);

pub struct SerializedRemote {
    remote: L64,
    rev: L64,
    states: L64,
    id_rev: L64,
    path: SmallStr,
}

pub struct T8([L64; 8]);

pub struct SerializedChannel {
    graph: L64,
    changes: L64,
    revchanges: L64,
    states: L64,
    tags: L64,
    apply_counter: L64,
    last_modified: L64,
    id: RemoteId,
}

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

    pub fn id(&self) -> &RemoteId {
        &self.id

    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(())
    }

    pub id_rev: L64,
    pub path: SmallString,

    name: SmallString,

    id: RemoteId,

            name: self.name.clone(),

            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

    }
}
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))

    fn id<'a>(&self, c: &'a Self::Channel) -> &'a RemoteId;

    cursor!(channels, SmallStr, T8);

    cursor!(channels, SmallStr, SerializedChannel);

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

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

        start: &str,

        start: &RemoteId,

    cursor!(remotes, SmallStr, T3);

    cursor!(remotes, RemoteId, SerializedRemote);

        name: &str,

        name: RemoteId,

}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct SerializedPublicKey {
    algorithm: crate::key::Algorithm,
    key: [u8; 32],

// #[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());
        }
    }
}

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

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

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

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

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

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

    pub fn from_basename(b: &[u8]) -> Self {
        use byteorder::ByteOrder;
        InodeMetadata(byteorder::BigEndian::read_u16(b))
    }

use ed25519_dalek::Signer;

pub const CONTEXT: &'static [u8] = b"pijul";

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

    #[error("Base 58 decoding error")]
    Encoding(#[from] bs58::decode::Error),

}
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
    }

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

    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires: Option<chrono::DateTime<chrono::Utc>>,

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

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

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

    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires: Option<chrono::DateTime<chrono::Utc>>,

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

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

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

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

                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()))

                let sig = key.sign(&h);
                Ok(bs58::encode(&sig.to_bytes()).into_string())

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

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

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

                    key: bs58::encode(&key).into_string(),

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

                let sig = key.sign(&to_sign);

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

                    key: bs58::encode(&key.public.clone().to_bytes()).into_string(),
                    signature: bs58::encode(&sig.to_bytes()).into_string(),

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

                let sig = key.sign(&to_sign);

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

                    signature: bs58::encode(&sig.to_bytes()).into_string(),

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

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

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

                let mut key_enc = [0; 64];
                bs58::decode(self.key.as_bytes()).into(&mut key_enc)?;

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

                let mut hash = ed25519_dalek::Sha512::new();
                hash.update(&signed);
                bs58::encode(&hash.finalize()).into_string()

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

                let mut key = [0; 32];
                bs58::decode(self.key.as_bytes()).into(&mut key)?;
                let key = ed25519_dalek::PublicKey::from_bytes(&key)?;

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

                bs58::decode(self.signature.as_bytes()).into(&mut signature)?;

                let signed =

                let msg =

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

                key.verify_strict(&msg, &signature)?;

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

                key: bs58::encode(key.as_bytes()).into_string(),

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

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

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

                bs58::decode(signature.as_bytes()).into(&mut sig)?;

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

                key.verify_strict(&h, &sig)?;

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

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[repr(u8)]

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,
        }
    }
}

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

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

            use byteorder::ByteOrder;

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

                metadata: InodeMetadata::from_basename(a),

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

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

pub struct ChangeHeader {

pub struct ChangeHeader_<Author> {

#[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()
        }
    }
}

/// 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>;

pub struct LocalChange<Hunk> {

pub struct LocalChange<Hunk, Author> {

    pub hashed: Hashed<Hunk>,

    pub hashed: Hashed<Hunk, Author>,

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

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

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

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

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Author(pub std::collections::BTreeMap<String, String>);

pub struct Hashed<Hunk> {

pub struct Hashed<Hunk, Author> {

    pub header: ChangeHeader,

    pub header: ChangeHeader_<Author>,

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

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

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

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

        if offsets.version != VERSION {

        if offsets.version != VERSION && offsets.version != VERSION_NOENC {

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

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

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

        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()
        };

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

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

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

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

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

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

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

            let s = toml::ser::to_string_pretty(&self.header)?;
            writeln!(w, "{}", s)?;

        let encoding = Some(crate::text_encoding::Encoding(encoding_rs::UTF_8));

                encoding: None,

                encoding,

                encoding: None,

                encoding,

                encoding: None,

                encoding,

                encoding: None,

                encoding,

                encoding: None,

                encoding,

                encoding: None,

                encoding,

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

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

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

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

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

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

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

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

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 {

            header: hashed.header,

            header: hashed.header.into(),

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)
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

bs58 = "0.4"

version = 3

version = "0.15.1"

version = "0.15.2"

checksum = "03345e98af8f3d786b6d9f656ccfa6ac316d954e92bc4841f0bba20789d5fb5a"

checksum = "e7a2e47a1fbe209ee101dd6d61285226744c6c8d3c21c8dc878ba6cb9f467f3a"

version = "1.0.40"

version = "1.0.41"

checksum = "28b2cd92db5cbd74e8e5028f7e27dd7aa3090e89e4f2a197cc7c8dfb69c7063b"

checksum = "15af2628f6890fe2609a3b91bef4c83450512802e59489f9c1cb1fa5df064a61"

version = "0.3.59"

version = "0.3.60"

checksum = "4717cfcbfaa661a0fd48f8453951837ae7e8f81e481fbb136e3202d72805a744"

checksum = "b7815ea54e4d821e791162e078acbebfd6d8c8939cd559c9335dceb1c8ca7282"

[[package]]
name = "bs58"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3"

version = "0.1.12"

version = "0.1.13"

checksum = "459978032e1aa8d5ca411ee0057ea84f98a93a648ff9f78654e53f33447cf0f9"

checksum = "81a81b0d8f8ee23417182818b4f06312c5f535c2b04eef1773f7c24bbdf8c500"

version = "0.1.4"

version = "0.1.5"

checksum = "ed00c67cb5d0a7d64a44f6ad2668db7e7530311dd53ea79bcd4fb022c64911c8"

checksum = "66c99696f6c9dd7f35d486b9d04d7e6e202aa3e8c40d553f2fdf5e7e0c6a71ef"

version = "0.8.3"