use std::io::Write;

use std::sync::Arc;

    pub working_copy: libpijul::working_copy::filesystem::FileSystem,

    pub working_copy: Arc<libpijul::working_copy::filesystem::FileSystem>,

    pub fn config_path(&self) -> PathBuf {
        self.path.join(DOT_DIR).join(CONFIG_FILE)
    }

        let config = toml::to_string(&self.config)?;
        let mut file = std::fs::File::create(&self.path.join(DOT_DIR).join(CONFIG_FILE))?;
        file.write_all(config.as_bytes())?;

        self.config.save(&self.config_path())?;

            working_copy: libpijul::working_copy::filesystem::FileSystem::from_root(

            working_copy: Arc::new(libpijul::working_copy::filesystem::FileSystem::from_root(

            ),

            )),

                working_copy: libpijul::working_copy::filesystem::FileSystem::from_root(&cur),

                working_copy: Arc::new(libpijul::working_copy::filesystem::FileSystem::from_root(
                    &cur,
                )),

            .dichotomy_changelist(txn, &remote.borrow().remote)

            .dichotomy_changelist(txn, &remote.lock()?.remote)

            .iter_remote(&remote.borrow().remote, n)?

            .iter_remote(&remote.lock()?.remote, n)?

        for x in txn.iter_remote(&remote.borrow().remote, 0)? {

        for x in txn.iter_remote(&remote.lock()?.remote, 0)? {

            let channel = local_channel.borrow();

            let channel = local_channel.read()?;

        for x in txn.iter_remote(&remote_changes.borrow().remote, 0)? {

        for x in txn.iter_remote(&remote_changes.lock()?.remote, 0)? {

use std::sync::Arc;

use std::sync::{Arc, RwLock};

        Ok(txn.reverse_log(&channel.borrow(), None)?.next().map(|n| {

        Ok(txn.reverse_log(&*channel.read()?, None)?.next().map(|n| {

                        &remote_channel.borrow().graph,

                        &remote_channel.read()?.graph,

        for x in remote_txn.log(&remote_channel.borrow(), from)? {

        for x in remote_txn.log(&*remote_channel.read()?, from)? {

        let mut repo = libpijul::working_copy::filesystem::FileSystem::from_root(&self.root);

        let repo = libpijul::working_copy::filesystem::FileSystem::from_root(&self.root);

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

        let txn = Arc::new(RwLock::new(txn));
        let wc = Arc::new(repo);
        libpijul::output::output_repository_no_pending(
            wc,
            &store,
            txn.clone(),
            channel.clone(),
            "",
            true,
            None,
            num_cpus::get(),
        )?;
        let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap()
        } else {
            unreachable!()
        };

    #[cfg(debug_assertions)]

    // #[cfg(debug_assertions)]

        #[cfg(debug_assertions)]

        // #[cfg(debug_assertions)]

use std::io::Write;

            use std::io::Write;

    pub fn save(&self, path: &std::path::Path) -> Result<(), anyhow::Error> {
        let config = toml::to_string(self)?;
        let mut file = std::fs::File::create(path)?;
        file.write_all(config.as_bytes())?;
        Ok(())
    }

use std::sync::{Arc, RwLock};

        let mut txn = repo.pristine.mut_txn_begin()?;
        if let Some(mut channel) = txn.load_channel(channel_name)? {
            let pending_hash = if self.reset {
                super::pending(&mut txn, &mut channel, &mut repo)?
            } else {
                None
            };

        let txn = repo.pristine.mut_txn_begin()?;
        let channel = if let Some(channel) = txn.load_channel(channel_name)? {
            channel
        } else {
            bail!("No such channel: {:?}", channel_name);
        };
        let txn = Arc::new(RwLock::new(txn));
        let pending_hash = if self.reset {
            super::pending(txn.clone(), &channel, &mut repo)?
        } else {
            None
        };
        let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap()
        } else {
            unreachable!()
        };

            let mut hashes = Vec::new();

        let mut hashes = Vec::new();

            if self.change_id.is_empty() {
                // No change ids were given, present a list for choosing
                // The number can be set in the global config or passed as a command-line option
                let number_of_changes = if let Some(n) = self.show_changes {
                    n
                } else {
                    let cfg = crate::config::Global::load()?;
                    cfg.unrecord_changes.ok_or_else(|| {
                        anyhow!(
                            "Can't determine how many changes to show. \
                            Please set the `unrecord_changes` option in \
                            your global config or run `pijul unrecord` \
                            with the `--show-changes` option."
                        )
                    })?
                };
                let hashes_ = txn
                    .reverse_log(&channel.borrow(), None)?
                    .map(|h| (h.unwrap().1).0.into())
                    .take(number_of_changes)
                    .collect::<Vec<_>>();
                let o = make_changelist(&repo.changes, &hashes_, "unrecord")?;
                for h in parse_changelist(&edit::edit_bytes(&o[..])?).iter() {
                    hashes.push((*h, *txn.get_internal(&h.into())?.unwrap()))
                }

        if self.change_id.is_empty() {
            // No change ids were given, present a list for choosing
            // The number can be set in the global config or passed as a command-line option
            let number_of_changes = if let Some(n) = self.show_changes {
                n

                for c in self.change_id.iter() {
                    let (hash, cid) = txn.hash_from_prefix(c)?;
                    hashes.push((hash, cid))
                }

                let cfg = crate::config::Global::load()?;
                cfg.unrecord_changes.ok_or_else(|| {
                    anyhow!(
                        "Can't determine how many changes to show. \
                         Please set the `unrecord_changes` option in \
                         your global config or run `pijul unrecord` \
                         with the `--show-changes` option."
                    )
                })?

            let channel_ = channel.borrow();
            let mut changes: Vec<(Hash, ChangeId, Option<u64>)> = Vec::new();
            for (hash, change_id) in hashes {
                let n = txn
                    .get_changeset(txn.changes(&channel_), &change_id)
                    .unwrap();
                changes.push((hash, change_id, n.map(|&x| x.into())));

            let hashes_ = txn
                .reverse_log(&*channel.read()?, None)?
                .map(|h| (h.unwrap().1).0.into())
                .take(number_of_changes)
                .collect::<Vec<_>>();
            let o = make_changelist(&repo.changes, &hashes_, "unrecord")?;
            for h in parse_changelist(&edit::edit_bytes(&o[..])?).iter() {
                hashes.push((*h, *txn.get_internal(&h.into())?.unwrap()))
            }
        } else {
            for c in self.change_id.iter() {
                let (hash, cid) = txn.hash_from_prefix(c)?;
                hashes.push((hash, cid))

            std::mem::drop(channel_);
            changes.sort_by(|a, b| b.2.cmp(&a.2));
            for (hash, change_id, _) in changes {
                let channel_ = channel.borrow();
                for p in txn.iter_revdep(&change_id)? {
                    let (p, d) = p?;
                    if p < &change_id {
                        continue;
                    } else if p > &change_id {
                        break;

        };
        let channel_ = channel.read()?;
        let mut changes: Vec<(Hash, ChangeId, Option<u64>)> = Vec::new();
        for (hash, change_id) in hashes {
            let n = txn
                .get_changeset(txn.changes(&channel_), &change_id)
                .unwrap();
            changes.push((hash, change_id, n.map(|&x| x.into())));
        }
        std::mem::drop(channel_);
        changes.sort_by(|a, b| b.2.cmp(&a.2));
        for (hash, change_id, _) in changes {
            let channel_ = channel.read()?;
            for p in txn.iter_revdep(&change_id)? {
                let (p, d) = p?;
                if p < &change_id {
                    continue;
                } else if p > &change_id {
                    break;
                }
                if txn.get_changeset(txn.changes(&channel_), d)?.is_some() {
                    let dep: Hash = txn.get_external(d)?.unwrap().into();
                    if Some(dep) == pending_hash {
                        bail!(
                            "Cannot unrecord change {} because unrecorded changes depend on it",
                            hash.to_base32()
                        );
                    } else {
                        bail!(
                            "Cannot unrecord change {} because {} depend on it",
                            hash.to_base32(),
                            dep.to_base32()
                        );

                    if txn.get_changeset(txn.changes(&channel_), d)?.is_some() {
                        let dep: Hash = txn.get_external(d)?.unwrap().into();
                        if Some(dep) == pending_hash {
                            bail!(
                                "Cannot unrecord change {} because unrecorded changes depend on it",
                                hash.to_base32()
                            );
                        } else {
                            bail!(
                                "Cannot unrecord change {} because {} depend on it",
                                hash.to_base32(),
                                dep.to_base32()
                            );
                        }
                    }

                std::mem::drop(channel_);
                txn.unrecord(&repo.changes, &mut channel, &hash)?;

            if self.reset && is_current_channel {
                txn.output_repository_no_pending(
                    &mut repo.working_copy,
                    &repo.changes,
                    &mut channel,
                    "",
                    true,
                    None,
                )?;

            std::mem::drop(channel_);
            txn.unrecord(&repo.changes, &channel, &hash)?;
        }
        let txn = Arc::new(RwLock::new(txn));
        if self.reset && is_current_channel {
            libpijul::output::output_repository_no_pending(
                repo.working_copy.clone(),
                &repo.changes,
                txn.clone(),
                channel.clone(),
                "",
                true,
                None,
                num_cpus::get(),
            )?;
        }
        if let Some(h) = pending_hash {
            txn.write().unwrap().unrecord(&repo.changes, &channel, &h)?;
            if cfg!(feature = "keep-changes") {
                repo.changes.del_change(&h)?;

            if let Some(h) = pending_hash {
                txn.unrecord(&repo.changes, &mut channel, &h)?;
                if cfg!(feature = "keep-changes") {
                    repo.changes.del_change(&h)?;
                }
            }

        let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap()
        } else {
            unreachable!()
        };

use std::sync::{Arc, RwLock};

use libpijul::{ChannelTxnT, DepsTxnT, MutTxnT, MutTxnTExt, TxnT, TxnTExt};
use log::debug;

use libpijul::{ChannelTxnT, DepsTxnT, MutTxnT, TxnT, TxnTExt};
use log::*;

        let mut repo = Repository::find_root(self.repo_path).await?;
        let mut txn = repo.pristine.mut_txn_begin()?;
        let (channel_name, _) = repo.config.get_current_channel(self.channel.as_deref());

        let repo = Repository::find_root(self.repo_path).await?;
        let txn = repo.pristine.mut_txn_begin()?;
        let config_path = repo.config_path();
        let mut config = repo.config;
        let (channel_name, _) = config.get_current_channel(self.channel.as_deref());

        let mut channel = if let Some(channel) = txn.load_channel(&channel_name)? {

        let channel = if let Some(channel) = txn.load_channel(&channel_name)? {

            txn.output_file(

            libpijul::output::output_file(

                &channel,

                &txn,
                &channel.read().unwrap(),

        } else {
            let (current_channel, _) = repo.config.get_current_channel(None);
            if self.channel.as_deref() == Some(current_channel) {
                if !overwrite_changes {
                    return Ok(());
                }
            } else if self.channel.is_some() {
                if !self.files.is_empty() {
                    bail!("Cannot use --channel with individual paths. Did you mean --dry-run?")

            return Ok(());
        }
        let txn = Arc::new(RwLock::new(txn));
        let (current_channel, _) = config.get_current_channel(None);
        if self.channel.as_deref() == Some(current_channel) {
            if !overwrite_changes {
                return Ok(());
            }
        } else if self.channel.is_some() {
            if !self.files.is_empty() {
                bail!("Cannot use --channel with individual paths. Did you mean --dry-run?")
            }
            let channel = {
                let txn = txn.read().unwrap();
                txn.load_channel(current_channel)?
            };
            if let Some(channel) = channel {
                let mut state = libpijul::RecordBuilder::new();
                state.record(
                    txn.clone(),
                    libpijul::Algorithm::default(),
                    channel.clone(),
                    repo.working_copy.clone(),
                    &repo.changes,
                    "",
                    num_cpus::get(),
                )?;
                let rec = state.finish();
                debug!("actions = {:?}", rec.actions);
                if !rec.actions.is_empty() {
                    bail!("Cannot change channel, as there are unrecorded changes.")

                if let Some(mut channel) = txn.load_channel(current_channel)? {
                    let mut state = libpijul::RecordBuilder::new();
                    txn.record(
                        &mut state,
                        libpijul::Algorithm::default(),
                        &mut channel,
                        &mut repo.working_copy,
                        &repo.changes,
                        "",
                    )?;
                    let rec = state.finish();
                    debug!("actions = {:?}", rec.actions);
                    if !rec.actions.is_empty() {
                        bail!("Cannot change channel, as there are unrecorded changes.")
                    }
                }

        }

            let now = std::time::Instant::now();
            if self.files.is_empty() {
                if self.channel.is_none() || self.channel.as_deref() == Some(current_channel) {
                    let last_modified = last_modified(&txn, &channel.borrow());
                    txn.output_repository_no_pending(
                        &mut repo.working_copy,
                        &repo.changes,
                        &mut channel,
                        "",
                        true,
                        Some(last_modified),
                    )?;
                    txn.touch_channel(&mut channel.borrow_mut(), None);
                    txn.commit()?;
                    return Ok(());
                }
                let mut inodes = HashSet::new();
                if let Some(cur) = txn.load_channel(current_channel)? {
                    let mut changediff = HashSet::new();
                    let (a, b, s) = libpijul::pristine::last_common_state(
                        &txn,
                        &cur.borrow(),
                        &channel.borrow(),
                    )?;
                    debug!("last common state {:?}", s);
                    changes_after(&txn, &cur.borrow(), a, &mut changediff, &mut inodes)?;
                    changes_after(&txn, &channel.borrow(), b, &mut changediff, &mut inodes)?;
                }

        let now = std::time::Instant::now();
        if self.files.is_empty() {
            if self.channel.is_none() || self.channel.as_deref() == Some(current_channel) {
                let last_modified = last_modified(&*txn.read().unwrap(), &*channel.read()?);
                libpijul::output::output_repository_no_pending(
                    repo.working_copy.clone(),
                    &repo.changes,
                    txn.clone(),
                    channel.clone(),
                    "",
                    true,
                    Some(last_modified),
                    num_cpus::get(),
                )?;
                let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
                    txn.into_inner().unwrap()
                } else {
                    unreachable!()
                };
                txn.touch_channel(&mut *channel.write()?, None);
                txn.commit()?;
                return Ok(());
            }
            let mut inodes = HashSet::new();
            let txn_ = txn.read().unwrap();
            if let Some(cur) = txn_.load_channel(current_channel)? {
                let mut changediff = HashSet::new();
                let (a, b, s) = libpijul::pristine::last_common_state(
                    &*txn_,
                    &*cur.read()?,
                    &*channel.read()?,
                )?;
                debug!("last common state {:?}", s);
                changes_after(&*txn_, &*cur.read()?, a, &mut changediff, &mut inodes)?;
                changes_after(&*txn_, &*channel.read()?, b, &mut changediff, &mut inodes)?;
            }

                if self.channel.is_some() {
                    repo.config.current_channel = self.channel;
                    repo.save_config()?;

            if self.channel.is_some() {
                config.current_channel = self.channel;
                config.save(&config_path)?;
            }
            let mut paths = Vec::with_capacity(inodes.len());
            for pos in inodes.iter() {
                if let Some((path, _)) =
                    libpijul::fs::find_path(&repo.changes, &*txn_, &*channel.read()?, false, *pos)?
                {
                    paths.push(path)
                } else {
                    paths.clear();
                    break;

                let mut paths = Vec::with_capacity(inodes.len());
                for pos in inodes.iter() {
                    if let Some((path, _)) = libpijul::fs::find_path(
                        &repo.changes,
                        &txn,
                        &channel.borrow(),
                        false,
                        *pos,
                    )? {
                        paths.push(path)
                    } else {
                        paths.clear();
                        break;
                    }
                }
                PROGRESS
                    .borrow_mut()
                    .unwrap()
                    .push(crate::progress::Cursor::Spin {
                        i: 0,
                        pre: "Outputting repository".into(),
                    });
                for path in paths.iter() {
                    debug!("resetting {:?}", path);
                    txn.output_repository_no_pending(
                        &mut repo.working_copy,
                        &repo.changes,
                        &mut channel,
                        &path,
                        true,
                        None,
                    )?;
                }
                if paths.is_empty() {
                    txn.output_repository_no_pending(
                        &mut repo.working_copy,
                        &repo.changes,
                        &mut channel,
                        "",
                        true,
                        None,
                    )?;
                }
                PROGRESS.join();
            } else {
                PROGRESS
                    .borrow_mut()
                    .unwrap()
                    .push(crate::progress::Cursor::Spin {
                        i: 0,
                        pre: "Outputting repository".into(),
                    });
                for root in self.files.iter() {
                    let root = std::fs::canonicalize(&root)?;
                    let path = root.strip_prefix(&repo_path)?.to_str().unwrap();
                    txn.output_repository_no_pending(
                        &mut repo.working_copy,
                        &repo.changes,
                        &mut channel,
                        &path,
                        true,
                        None,
                    )?;
                }
                PROGRESS.join();

            }
            PROGRESS
                .borrow_mut()
                .unwrap()
                .push(crate::progress::Cursor::Spin {
                    i: 0,
                    pre: "Outputting repository".into(),
                });
            std::mem::drop(txn_);
            for path in paths.iter() {
                debug!("resetting {:?}", path);
                libpijul::output::output_repository_no_pending(
                    repo.working_copy.clone(),
                    &repo.changes,
                    txn.clone(),
                    channel.clone(),
                    &path,
                    true,
                    None,
                    num_cpus::get(),
                )?;
            }
            if paths.is_empty() {
                libpijul::output::output_repository_no_pending(
                    repo.working_copy,
                    &repo.changes,
                    txn.clone(),
                    channel,
                    "",
                    true,
                    None,
                    num_cpus::get(),
                )?;
            }
            PROGRESS.join();
        } else {
            PROGRESS
                .borrow_mut()
                .unwrap()
                .push(crate::progress::Cursor::Spin {
                    i: 0,
                    pre: "Outputting repository".into(),
                });
            for root in self.files.iter() {
                let root = std::fs::canonicalize(&root)?;
                let path = root.strip_prefix(&repo_path)?.to_str().unwrap();
                libpijul::output::output_repository_no_pending(
                    repo.working_copy.clone(),
                    &repo.changes,
                    txn.clone(),
                    channel.clone(),
                    &path,
                    true,
                    None,
                    num_cpus::get(),
                )?;

            txn.commit()?;
            debug!("now = {:?}", now.elapsed());

            PROGRESS.join();

        let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap()
        } else {
            unreachable!()
        };
        txn.commit()?;
        debug!("now = {:?}", now.elapsed());

        debug!(

        info!(

use std::collections::{HashMap, HashSet};

use std::sync::{Arc, RwLock};

use libpijul::pristine::ChannelMutTxnT;
use libpijul::{Base32, ChannelRef, ChannelTxnT, MutTxnT, MutTxnTExt, TxnT, TxnTExt};

use libpijul::{
    Base32, ChannelMutTxnT, ChannelRef, ChannelTxnT, MutTxnT, MutTxnTExt, TxnT, TxnTExt,
};
use libpijul::{HashMap, HashSet};

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

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

                .get_changeset(txn.changes(&channel.borrow()), &c)?

                .get_changeset(txn.changes(&*channel.read()?), &c)?

                    channel.borrow().name

                    channel.read().unwrap().name

            } else if let Some(h) = txn.reverse_log(&channel.borrow(), None)?.next() {

            } else if let Some(h) = txn.reverse_log(&*channel.read()?, None)?.next() {

        let (repo_path, mut working_copy) = if let Some(ref w) = self.working_copy {

        let (repo_path, working_copy) = if let Some(ref w) = self.working_copy {

                Some(libpijul::working_copy::filesystem::FileSystem::from_root(w)),

                Some(Arc::new(
                    libpijul::working_copy::filesystem::FileSystem::from_root(w),
                )),

        let txn = Arc::new(RwLock::new(txn));

            &mut channel,
            working_copy.as_mut().unwrap_or(&mut repo.working_copy),

            channel.clone(),
            working_copy.clone().unwrap_or(repo.working_copy.clone()),

        if let Some((mut txn, mut change, updates, hash, oldest)) = result {

        if let Some((txn, mut change, updates, hash, oldest)) = result {

            let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
                txn.into_inner().unwrap()
            } else {
                unreachable!()
            };

                txn.touch_channel(&mut channel.borrow_mut(), Some(oldest));

                txn.touch_channel(&mut *channel.write()?, Some(oldest));

    fn record<T: TxnTExt + MutTxnTExt, C: ChangeStore>(

    fn record<
        T: TxnTExt + MutTxnTExt + Sync + Send + 'static,
        C: ChangeStore + Send + Clone + 'static,
    >(

        mut txn: T,
        channel: &mut ChannelRef<T>,
        working_copy: &mut libpijul::working_copy::FileSystem,

        txn: Arc<RwLock<T>>,
        channel: ChannelRef<T>,
        working_copy: Arc<libpijul::working_copy::FileSystem>,

            T,

            Arc<RwLock<T>>,

                        txn.record(
                            &mut state,

                        state.record(
                            txn.clone(),

                            channel,
                            working_copy,

                            channel.clone(),
                            working_copy.clone(),

                            num_cpus::get(),

                txn.record(
                    &mut state,

                state.record(
                    txn.clone(),

                    channel,
                    working_copy,

                    channel.clone(),
                    working_copy.clone(),

                    num_cpus::get(),

                &mut txn,
                channel,

                txn.clone(),
                channel.clone(),

            txn.touch_channel(&mut channel.borrow_mut(), None);

            let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
                txn.into_inner().unwrap()
            } else {
                unreachable!()
            };
            txn.touch_channel(&mut *channel.write()?, None);

        debug!("TAKING LOCK {}", line!());
        let txn_ = txn.write().unwrap();

            .map(|rec| rec.globalize(&txn).unwrap())

            .map(|rec| rec.globalize(&*txn_).unwrap())

        let contents = if let Ok(c) = Arc::try_unwrap(rec.contents) {
            c.into_inner().unwrap()
        } else {
            unreachable!()
        };

            LocalChange::make_change(&txn, channel, actions, rec.contents, header, Vec::new())?;

            LocalChange::make_change(&*txn_, &channel, actions, contents, header, Vec::new())?;

                    Change::read_and_deps(&mut change, &mut rec.updatables, &txn, channel)

                    Change::read_and_deps(&mut change, &mut rec.updatables, &*txn_, &channel)

        std::mem::drop(txn_);

use std::sync::{Arc, RwLock};

                libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?

                libpijul::fs::iter_graph_descendants(&txn, &channel.read()?.graph, p)?

        for x in txn.reverse_log(&channel.borrow(), None)? {

        for x in txn.reverse_log(&*channel.read()?, None)? {

                    let channel = channel.borrow();

                    let channel = channel.read()?;

                for x in txn.iter_remote(&remote_changes.borrow().remote, 0)? {

                for x in txn.iter_remote(&remote_changes.lock()?.remote, 0)? {

                        .channel_has_state(txn.states(&channel.borrow()), &p.b)?

                        .channel_has_state(txn.states(&*channel.read()?), &p.b)?

                        libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?

                        libpijul::fs::iter_graph_descendants(&txn, &channel.read()?.graph, p)?

                    let remote_channel = remote_channel.borrow();

                    let remote_channel = remote_channel.read()?;

                            .channel_has_state(txn.states(&channel.borrow()), &m)?

                            .channel_has_state(txn.states(&*channel.read()?), &m)?

                            .get_changeset(txn.changes(&channel.borrow()), h_int)?

                            .get_changeset(txn.changes(&*channel.read()?), h_int)?

        let hash = super::pending(&mut txn, &mut channel, &mut repo)?;

        let txn = Arc::new(RwLock::new(txn));
        let hash = super::pending(txn.clone(), &mut channel, &mut repo)?;
        let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap()
        } else {
            unreachable!()
        };

                        touched.insert(inode);

                        touched.insert(*inode);

        let txn = Arc::new(RwLock::new(txn));

                if let Some((path, _)) =
                    libpijul::fs::find_path(&repo.changes, &txn, &channel.borrow(), false, *i)?
                {

                if let Some((path, _)) = libpijul::fs::find_path(
                    &repo.changes,
                    &*txn.read().unwrap(),
                    &*channel.read()?,
                    false,
                    i,
                )? {

            let mut conflicts = Vec::new();

                txn.output_repository_no_pending(
                    &mut repo.working_copy,
                    &repo.changes,
                    &mut channel,
                    path,
                    true,
                    None,
                )?;

                conflicts.extend(
                    libpijul::output::output_repository_no_pending(
                        repo.working_copy.clone(),
                        &repo.changes,
                        txn.clone(),
                        channel.clone(),
                        path,
                        true,
                        None,
                        num_cpus::get(),
                    )?
                    .into_iter(),
                );

                txn.output_repository_no_pending(
                    &mut repo.working_copy,
                    &repo.changes,
                    &mut channel,
                    "",
                    true,
                    None,
                )?;

                conflicts.extend(
                    libpijul::output::output_repository_no_pending(
                        repo.working_copy.clone(),
                        &repo.changes,
                        txn.clone(),
                        channel.clone(),
                        "",
                        true,
                        None,
                        num_cpus::get(),
                    )?
                    .into_iter(),
                );

        let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap()
        } else {
            unreachable!()
        };

use std::sync::{Arc, RwLock};

                    for x in txn.log(&channel.borrow(), pos)? {

                    for x in txn.log(&*channel.read()?, pos)? {

                } else if let Some(x) = txn.reverse_log(&channel.borrow(), None)?.next() {

                } else if let Some(x) = txn.reverse_log(&*channel.read()?, None)?.next() {

                            libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?

                            libpijul::fs::iter_graph_descendants(&txn, &channel.read()?.graph, p)?

                for x in txn.log(&channel.borrow(), from)? {

                for x in txn.log(&*channel.read()?, from)? {

                    if txn.current_state(&channel.borrow())? == state && extra.is_empty() {

                    if txn.current_state(&*channel.read()?)? == state && extra.is_empty() {

        for (_, mut channel) in applied {
            txn.output_repository_no_pending(
                &mut repo.working_copy,

        let txn = Arc::new(RwLock::new(txn));
        for (_, channel) in applied {
            libpijul::output::output_repository_no_pending(
                repo.working_copy.clone(),

                &mut channel,

                txn.clone(),
                channel.clone(),

                num_cpus::get(),

            let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
                txn.into_inner().unwrap()
            } else {
                unreachable!()
            };

#[cfg(debug_assertions)]

// #[cfg(debug_assertions)]

#[cfg(debug_assertions)]

// #[cfg(debug_assertions)]

fn pending<T: libpijul::MutTxnTExt + libpijul::TxnT>(
    txn: &mut T,
    channel: &mut libpijul::ChannelRef<T>,

fn pending<T: libpijul::MutTxnTExt + libpijul::TxnT + Send + Sync + 'static>(
    txn: std::sync::Arc<std::sync::RwLock<T>>,
    channel: &libpijul::ChannelRef<T>,

    let recorded = txn.record_all(

    let mut builder = libpijul::record::Builder::new();
    builder.record(
        txn.clone(),

        channel,
        &mut repo.working_copy,

        channel.clone(),
        repo.working_copy.clone(),

        num_cpus::get(),

    let recorded = builder.finish();

    let mut txn = txn.write().unwrap();

        .map(|rec| rec.globalize(txn).unwrap())

        .map(|rec| rec.globalize(&*txn).unwrap())

    let contents = if let Ok(c) = std::sync::Arc::try_unwrap(recorded.contents) {
        c.into_inner().unwrap()
    } else {
        unreachable!()
    };

        txn,

        &*txn,

        recorded.contents,

        contents,

        libpijul::change::dependencies(txn, &channel.borrow(), pending_change.changes.iter())?;

        libpijul::change::dependencies(&*txn, &*channel.read()?, pending_change.changes.iter())?;

            for h in txn.reverse_log(&channel.borrow(), None)? {

            for h in txn.reverse_log(&*channel.read()?, None)? {

            for h in txn.reverse_log(&channel.borrow(), None)? {

            for h in txn.reverse_log(&*channel.read()?, None)? {

use std::sync::{Arc, RwLock};

        let mut txn = repo.pristine.mut_txn_begin()?;

        let txn = repo.pristine.mut_txn_begin()?;

        let txn = Arc::new(RwLock::new(txn));

                        &mut txn,

                        txn.clone(),

                let mut txn = txn.write().unwrap();

        txn.commit()?;

        if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap().commit()?;
        } else {
            unreachable!()
        }

use std::sync::{Arc, RwLock};

use libpijul::{MutTxnT, MutTxnTExt};

use libpijul::MutTxnT;

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

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

        let mut channel =

        let channel =

        let txn = Arc::new(RwLock::new(txn));

            txn.record(
                &mut state,

            state.record(
                txn.clone(),

                &mut channel,
                &mut repo.working_copy,

                channel.clone(),
                repo.working_copy.clone(),

                num_cpus::get(),

                &mut txn,
                &mut channel,

                txn.clone(),
                channel.clone(),

        let txn = txn.write().unwrap();

            .map(|rec| rec.globalize(&txn).unwrap())

            .map(|rec| rec.globalize(&*txn).unwrap())

        let contents = if let Ok(cont) = std::sync::Arc::try_unwrap(rec.contents) {
            cont.into_inner().unwrap()
        } else {
            unreachable!()
        };

            &txn,

            &*txn,

            rec.contents,

            contents,

            full_dependencies(&txn, &channel)?

            full_dependencies(&*txn, &channel)?

            dependencies(&txn, &channel.borrow(), change.changes.iter())?

            dependencies(&*txn, &*channel.read()?, change.changes.iter())?

            change.write(

            match change.write(

            )?

            ) {
                Ok(()) => {}
                Err(libpijul::change::TextSerError::Io(e))
                    if e.kind() == std::io::ErrorKind::BrokenPipe => {}
                Err(e) => return Err(e.into()),
            }

    #[clap(long = "sanakirja-only")]
    sanakirja_only: bool,

        libpijul::pristine::debug_inodes(&txn);
        libpijul::pristine::debug_revinodes(&txn);
        libpijul::pristine::debug_tree_print(&txn);
        libpijul::pristine::debug_revtree_print(&txn);

        if let Some(root) = self.root {
            let (pos, _) = txn
                .follow_oldest_path(&repo.changes, &channel, &root)
                .unwrap();
            libpijul::pristine::debug_root(
                &txn,
                &channel.borrow().graph,
                pos.inode_vertex(),
                std::io::stdout(),
                true,
            )?;
        } else {
            let channel = channel.borrow();
            libpijul::pristine::debug(&txn, &channel.graph, std::io::stdout())?;

        if !self.sanakirja_only {
            libpijul::pristine::debug_inodes(&txn);
            libpijul::pristine::debug_revinodes(&txn);
            libpijul::pristine::debug_tree_print(&txn);
            libpijul::pristine::debug_revtree_print(&txn);
            if let Some(root) = self.root {
                let (pos, _) = txn
                    .follow_oldest_path(&repo.changes, &channel, &root)
                    .unwrap();
                libpijul::pristine::debug_root(
                    &txn,
                    &channel.read()?.graph,
                    pos.inode_vertex(),
                    std::io::stdout(),
                    true,
                )?;
            } else {
                let channel = channel.read()?;
                libpijul::pristine::debug(&txn, &channel.graph, std::io::stdout())?;
            }
            libpijul::pristine::check_alive_debug(&repo.changes, &txn, &*channel.read()?, 0)?;

        libpijul::pristine::check_alive_debug(&repo.changes, &txn, &channel.borrow(), 0)?;

        let channel = channel.read()?;
        ::sanakirja::debug::debug(&txn.txn, &[&channel.graph], "debug.sanakirja", true);

        let channel_ = channel.borrow();

        txn.output_file(

        let channel = channel.read().unwrap();
        libpijul::output::output_file(

            &txn,

            &mut Creditor::new(std::io::stdout(), &txn, &channel_),

            &mut Creditor::new(std::io::stdout(), &txn, &channel),

use libpijul::{MutTxnT, MutTxnTExt};

use libpijul::MutTxnT;

use std::sync::{Arc, RwLock};

        let repo_path_ = path.clone();

        let repo_path_ = repo_path.clone();

            std::fs::remove_dir_all(&repo_path_).unwrap_or(());

            repo_path_.remove();

        txn.output_repository_no_pending(
            &mut repo.working_copy,

        let config_path = repo.config_path();
        let mut config = repo.config;
        let txn = Arc::new(RwLock::new(txn));
        libpijul::output::output_repository_no_pending(
            repo.working_copy.clone(),

            &mut channel,

            txn.clone(),
            channel,

            num_cpus::get(),

        let txn = if let Ok(t) = Arc::try_unwrap(txn) {
            t.into_inner().unwrap()
        } else {
            unreachable!()
        };

        repo.config.current_channel = Some(self.channel);

        config.current_channel = Some(self.channel);

            repo.config.default_remote = std::fs::canonicalize(&l.root)?

            config.default_remote = std::fs::canonicalize(&l.root)?

            repo.config.default_remote = Some(self.remote);

            config.default_remote = Some(self.remote);

        repo.save_config()?;

        config.save(&config_path)?;

                    let channel = channel?;
                    let channel = channel.borrow();
                    let name = txn.name(&channel);

                    let (_, channel) = channel?;
                    let channel = channel.read()?;
                    let name = txn.name(&*channel);

            let channel = channel.borrow();
            if let Some(h) = txn.reverse_log(&channel, None)?.next() {

            let channel = channel.read()?;
            if let Some(h) = txn.reverse_log(&*channel, None)?.next() {

use std::collections::{HashMap, HashSet};

use std::sync::{Arc, RwLock};

use libpijul::{HashMap, HashSet};

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

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

            let change = libpijul::change::Change::read(&mut change, &mut HashMap::new())?;

            let change = libpijul::change::Change::read(&mut change, &mut HashMap::default())?;

        let mut touched = HashSet::new();

        let mut touched = HashSet::default();

        let txn = Arc::new(RwLock::new(txn));

            let txn_ = txn.read().unwrap();

                    libpijul::fs::find_path(&repo.changes, &txn, &channel.borrow(), false, i)?

                    libpijul::fs::find_path(&repo.changes, &*txn_, &*channel.read()?, false, i)?

            std::mem::drop(txn_);

                txn.output_repository_no_pending(
                    &mut repo.working_copy,

                libpijul::output::output_repository_no_pending(
                    repo.working_copy.clone(),

                    &mut channel,

                    txn.clone(),
                    channel.clone(),

                    num_cpus::get(),

                txn.output_repository_no_pending(
                    &mut repo.working_copy,

                libpijul::output::output_repository_no_pending(
                    repo.working_copy.clone(),

                    &mut channel,

                    txn.clone(),
                    channel.clone(),

                    num_cpus::get(),

        let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap()
        } else {
            unreachable!()
        };

thrussh-keys = "0.20.1"

thrussh-keys = "0.20.3"

sanakirja = { version = "1.1.7", features = [ "crc32" ] }

sanakirja = { version = "1.2.0", features = [ "crc32" ] }

#[derive(Debug, Error)]
pub enum WriteError<E: std::error::Error + 'static> {
    #[error(transparent)]
    E(E),
    #[error(transparent)]
    Io(#[from] std::io::Error),
}

    type Error: std::error::Error;
    fn create_dir_all(&mut self, path: &str) -> Result<(), Self::Error>;

    type Error: std::error::Error + Send;
    fn create_dir_all(&self, path: &str) -> Result<(), Self::Error>;

    fn remove_path(&mut self, name: &str) -> Result<(), Self::Error>;
    fn rename(&mut self, former: &str, new: &str) -> Result<(), Self::Error>;
    fn set_permissions(&mut self, name: &str, permissions: u16) -> Result<(), Self::Error>;
    fn write_file<A, E: std::error::Error, F: FnOnce(&mut dyn std::io::Write) -> Result<A, E>>(
        &mut self,
        file: &str,
        writer: F,
    ) -> Result<A, WriteError<E>>;

    fn remove_path(&self, name: &str) -> Result<(), Self::Error>;
    fn rename(&self, former: &str, new: &str) -> Result<(), Self::Error>;
    fn set_permissions(&self, name: &str, permissions: u16) -> Result<(), Self::Error>;
    type Writer: std::io::Write;
    fn write_file(&self, file: &str) -> Result<Self::Writer, Self::Error>;

use std::collections::HashMap;

use crate::HashMap;
use std::sync::{Arc, Mutex};

pub struct Memory {
    pub files: FileTree,
    pub last_modified: SystemTime,

pub struct Memory(Mutex<Memory_>);
#[derive(Debug)]
struct Memory_ {
    files: FileTree,
    last_modified: SystemTime,

pub struct FileTree {

struct FileTree {

        contents: Vec<u8>,

        contents: Arc<Mutex<Vec<u8>>>,

        Self {

        Memory(Mutex::new(Memory_ {

        }

        }))

        let m = self.0.lock().unwrap();

        let mut current_files = vec![(String::new(), &self.files)];

        let mut current_files = vec![(String::new(), &m.files)];

                contents: file_contents,

                contents: Arc::new(Mutex::new(file_contents)),

                    children: HashMap::new(),

                    children: HashMap::default(),

    fn add_inode(&mut self, file: &str, inode: Inode) {
        let mut file_tree = &mut self.files;

    fn add_inode(&self, file: &str, inode: Inode) {
        let mut m = self.0.lock().unwrap();

        self.last_modified = last;

        m.last_modified = last;
        let mut file_tree = &mut m.files;

                            children: HashMap::new(),

                            children: HashMap::default(),

}

impl Memory_ {

        self.last_modified = SystemTime::now();

        self.last_modified = SystemTime::now();

    fn create_dir_all(&mut self, file: &str) -> Result<(), Self::Error> {
        if self.get_file(file).is_none() {

    fn create_dir_all(&self, file: &str) -> Result<(), Self::Error> {
        let m = self.0.lock().unwrap();
        if m.get_file(file).is_none() {

                        children: HashMap::new(),

                        children: HashMap::default(),

        match self.get_file(file) {

        let m = self.0.lock().unwrap();
        match m.get_file(file) {

        match self.get_file(file) {

        let m = self.0.lock().unwrap();
        match m.get_file(file) {

                buffer.extend(contents);

                buffer.extend(&contents.lock().unwrap()[..]);

        Ok(self.last_modified)

        let m = self.0.lock().unwrap();
        Ok(m.last_modified)

    fn remove_path(&mut self, path: &str) -> Result<(), Self::Error> {
        self.remove_path_(path);

    fn remove_path(&self, path: &str) -> Result<(), Self::Error> {
        self.0.lock().unwrap().remove_path_(path);

    fn rename(&mut self, old: &str, new: &str) -> Result<(), Self::Error> {

    fn rename(&self, old: &str, new: &str) -> Result<(), Self::Error> {

        if let Some(inode) = self.remove_path_(old) {

        let mut m = self.0.lock().unwrap();
        if let Some(inode) = m.remove_path_(old) {

    fn set_permissions(&mut self, file: &str, permissions: u16) -> Result<(), Self::Error> {

    fn set_permissions(&self, file: &str, permissions: u16) -> Result<(), Self::Error> {

        match self.get_file_mut(file) {

        let mut m = self.0.lock().unwrap();
        match m.get_file_mut(file) {

    fn write_file<A, E: std::error::Error, F: FnOnce(&mut dyn std::io::Write) -> Result<A, E>>(
        &mut self,
        file: &str,
        writer: F,
    ) -> Result<A, WriteError<E>> {
        match self.get_file_mut(file) {

    type Writer = Writer;
    fn write_file(&self, file: &str) -> Result<Self::Writer, Self::Error> {
        let mut m = self.0.lock().unwrap();
        match m.get_file_mut(file) {

                contents.clear();
                writer(contents).map_err(WriteError::E)

                contents.lock().unwrap().clear();
                Ok(Writer {
                    w: contents.clone(),
                })

                let mut contents = Vec::new();

                let contents = Arc::new(Mutex::new(Vec::new()));

                let a = writer(&mut contents).map_err(WriteError::E)?;

                        contents,

                        contents: contents.clone(),

                Ok(a)

                Ok(Writer { w: contents })

pub struct Writer {
    w: Arc<Mutex<Vec<u8>>>,
}
impl std::io::Write for Writer {
    fn write(&mut self, b: &[u8]) -> Result<usize, std::io::Error> {
        self.w.lock().unwrap().write(b)
    }
    fn flush(&mut self) -> Result<(), std::io::Error> {
        Ok(())
    }
}

use std::sync::{Arc, RwLock};

        T: crate::MutTxnTExt + crate::TxnTExt,
        C: crate::changestore::ChangeStore,

        T: crate::MutTxnTExt + crate::TxnTExt + Send + Sync + 'static,
        C: crate::changestore::ChangeStore + Clone + Send + 'static,

        &mut self,
        txn: &mut T,
        channel: &mut crate::pristine::ChannelRef<T>,

        self: Arc<Self>,
        txn: Arc<RwLock<T>>,
        channel: crate::pristine::ChannelRef<T>,

    ) -> Result<(), Error<C::Error, T::GraphError>> {

    ) -> Result<(), Error<C::Error, T::GraphError>>
    where
        T::Channel: Send + Sync,
    {

            self.record_prefix(
                txn,
                channel,

            self.clone().record_prefix(
                txn.clone(),
                channel.clone(),

        txn: &mut T,

        txn: Arc<RwLock<T>>,

        let mut txn = txn.write().unwrap();

        T: crate::MutTxnTExt + crate::TxnTExt,
        C: crate::changestore::ChangeStore,

        T: crate::MutTxnTExt + crate::TxnTExt + Send + Sync + 'static,
        C: crate::changestore::ChangeStore + Clone + Send + 'static,

        &mut self,
        txn: &mut T,
        channel: &mut crate::pristine::ChannelRef<T>,

        self: Arc<Self>,
        txn: Arc<RwLock<T>>,
        channel: crate::pristine::ChannelRef<T>,

    ) -> Result<(), Error<C::Error, T::GraphError>> {

    ) -> Result<(), Error<C::Error, T::GraphError>>
    where
        T::Channel: Send + Sync,
    {

            self.add_prefix_rec(txn, repo_path, full, &prefix, threads)?;

            self.add_prefix_rec(txn.clone(), repo_path, full, &prefix, threads)?;

            txn.record(
                state,

            state.record(
                txn.clone(),

                1,

    fn create_dir_all(&mut self, file: &str) -> Result<(), Self::Error> {

    fn create_dir_all(&self, file: &str) -> Result<(), Self::Error> {
        debug!("create_dir_all {:?}", file);

        debug!("metadata {:?}", file);

        debug!("read_file {:?}", file);

        debug!("modified_time {:?}", file);

    fn remove_path(&mut self, path: &str) -> Result<(), Self::Error> {

    fn remove_path(&self, path: &str) -> Result<(), Self::Error> {
        debug!("remove_path {:?}", path);

    fn rename(&mut self, former: &str, new: &str) -> Result<(), Self::Error> {

    fn rename(&self, former: &str, new: &str) -> Result<(), Self::Error> {
        debug!("rename {:?} {:?}", former, new);

    fn set_permissions(&mut self, name: &str, permissions: u16) -> Result<(), Self::Error> {

    fn set_permissions(&self, name: &str, permissions: u16) -> Result<(), Self::Error> {

        current.set_mode(current.mode() | permissions as u32);

        if permissions & 0o100 != 0 {
            current.set_mode(current.mode() | 0o100);
        } else {
            current.set_mode(current.mode() & ((!0o777) | 0o666));
        }
        debug!("setting {:?}", current);

        debug!("set");

    fn write_file<A, E: std::error::Error, F: FnOnce(&mut dyn std::io::Write) -> Result<A, E>>(
        &mut self,
        file: &str,
        writer: F,
    ) -> Result<A, WriteError<E>> {

    type Writer = std::io::BufWriter<std::fs::File>;
    fn write_file(&self, file: &str) -> Result<Self::Writer, Self::Error> {

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

            std::fs::create_dir_all(p).map_err(WriteError::Io)?

            std::fs::create_dir_all(p).unwrap_or(())

        debug!("write_file: dir created");

        let mut file =
            std::io::BufWriter::new(std::fs::File::create(&path).map_err(WriteError::Io)?);
        writer(&mut file).map_err(WriteError::E)

        let file = std::io::BufWriter::new(std::fs::File::create(&path)?);
        debug!("file");
        Ok(file)

    channel: &mut ChannelRef<T>,

    channel: &ChannelRef<T>,

    let mut channel = channel.r.borrow_mut();

    let mut channel = channel.write().unwrap();

    let channel = channel.borrow();

    let channel = channel.read().unwrap();

        let br = br?;
        let br = br.borrow();
        if txn.name(&br) != txn.name(&channel)
            && txn.get_changeset(txn.changes(&br), &change_id)?.is_some()
        {

        let (name, br) = br?;
        if name.as_str() == txn.name(&channel) {
            continue;
        }
        let br = br.read().unwrap();
        if txn.get_changeset(txn.changes(&br), &change_id)?.is_some() {

                change,

    change: &Change,

            |h| change.knows(h),

    let mut txn = env.mut_txn_begin();

    let mut txn = env.mut_txn_begin().unwrap();

    let mut txn = env.mut_txn_begin();

    let mut txn = env.mut_txn_begin().unwrap();

    let mut txn = env.mut_txn_begin();

    let mut txn = env.mut_txn_begin().unwrap();