let (mut send, mut recv) = tokio::sync::mpsc::channel(100);

        let (mut send, recv) = tokio::sync::mpsc::channel(100);

        let mut waiting = 0;

                waiting += 1;

        std::mem::drop(hash_send);

        let (u, mut to_apply) = self
            .download_changes_rec(repo, hash_send, recv, pro_a, waiting)
            .await?;

        for h in to_apply {

        while let Some(h) = to_apply.recv().await {

            while to_download.contains(&h) {
                debug!("waiting for {:?}", h);
                if let Some((h, _)) = recv.recv().await {
                    debug!("recv {:?}", h);
                    to_download.remove(&h);
                } else {
                    break;
                }
            }

                    if let CS::Change(h) = h {

                    if let CS::Change(ref h) = h {

                || { inodes.iter().any(|i| CS::Change(i.change) == *h) };

                || { inodes.iter().any(|i| CS::Change(i.change) == h) };

                to_apply_inodes.push(*h);

                to_apply_inodes.push(h);

                    txn.apply_change_ws(&repo.changes, &mut channel, h, &mut ws)?;

                    txn.apply_change_rec_ws(&repo.changes, &mut channel, &h, &mut ws)?;

        std::mem::drop(recv);

        u.await??;

    async fn download_changes_rec(
        &mut self,
        repo: &mut Repository,
        send_hash: tokio::sync::mpsc::UnboundedSender<CS>,
        mut recv_signal: tokio::sync::mpsc::Receiver<(CS, bool)>,
        pro_n: usize,
        mut waiting: usize,
    ) -> Result<
        (
            tokio::task::JoinHandle<Result<(), anyhow::Error>>,
            tokio::sync::mpsc::Receiver<CS>,
        ),
        anyhow::Error,
    > {
        let (send_ready, recv_ready) = tokio::sync::mpsc::channel(100);
        let mut change_path = repo.changes_dir.clone();
        let mut dep_path = repo.changes_dir.clone();
        let changes = repo.changes.clone();
        let t = tokio::spawn(async move {
            let mut ready = Vec::new();
            while let Some((hash, follow)) = recv_signal.recv().await {
                if let CS::Change(hash) = hash {
                    waiting -= 1;
                    if follow {
                        libpijul::changestore::filesystem::push_filename(&mut change_path, &hash);
                        std::fs::create_dir_all(change_path.parent().unwrap())?;
                        use libpijul::changestore::ChangeStore;
                        let mut needs_dep = false;
                        for dep in changes.get_dependencies(&hash)? {
                            let dep: libpijul::pristine::Hash = dep;
                            libpijul::changestore::filesystem::push_filename(&mut dep_path, &dep);
                            let has_dep = std::fs::metadata(&dep_path).is_ok();
                            libpijul::changestore::filesystem::pop_filename(&mut dep_path);

                            if !has_dep {
                                needs_dep = true;
                                PROGRESS.borrow_mut().unwrap()[pro_n].incr_len();
                                send_hash.send(CS::Change(dep))?;
                                waiting += 1
                            }
                        }
                        libpijul::changestore::filesystem::pop_filename(&mut change_path);
                        if !needs_dep {
                            send_ready.send(CS::Change(hash)).await?;
                        } else {
                            ready.push(CS::Change(hash))
                        }
                    } else {
                        send_ready.send(CS::Change(hash)).await?;
                    }
                }
                if waiting == 0 {
                    break;
                }
            }
            for r in ready {
                send_ready.send(r).await?;
            }
            std::mem::drop(recv_signal);
            Ok(())
        });
        Ok((t, recv_ready))
    }

        let (mut send_signal, mut recv_signal) = tokio::sync::mpsc::channel(100);

        let mut change_path_ = repo.changes_dir.clone();

        let (mut send_signal, recv_signal) = tokio::sync::mpsc::channel(100);

        let mut change_path_ = repo.changes_dir.clone();

        let (u, mut recv_ready) = self
            .download_changes_rec(repo, send_hash, recv_signal, pro_n, waiting)
            .await?;

        let mut change_path = repo.changes_dir.clone();

        while let Some((hash, follow)) = recv_signal.recv().await {
            if let CS::Change(hash) = hash {
                waiting -= 1;
                if follow {
                    libpijul::changestore::filesystem::push_filename(&mut change_path, &hash);
                    std::fs::create_dir_all(change_path.parent().unwrap())?;
                    use libpijul::changestore::ChangeStore;
                    hashes.push(CS::Change(hash));
                    for dep in repo.changes.get_dependencies(&hash)? {
                        let dep: libpijul::pristine::Hash = dep;
                        PROGRESS.borrow_mut().unwrap()[pro_n].incr_len();
                        send_hash.send(CS::Change(dep))?;
                        waiting += 1
                    }
                    libpijul::changestore::filesystem::pop_filename(&mut change_path);
                }
            }
            if waiting == 0 {
                break
            }
        }
        std::mem::drop(recv_signal);
        std::mem::drop(send_hash);

            for hash in hashes.iter().rev() {
                if let CS::Change(hash) = hash {

            while let Some(hash) = recv_ready.recv().await {
                if let CS::Change(ref hash) = hash {

                hashes.push(hash);

        u.await??;

        libpijul::output::output_repository_no_pending(
            &repo.working_copy,
            &repo.changes,
            &txn,
            &channel,
            "",
            true,
            None,
            1, // num_cpus::get(),
            self.salt.unwrap_or(0),
        )?;

        if self.partial_paths.is_empty() {
            libpijul::output::output_repository_no_pending(
                &repo.working_copy,
                &repo.changes,
                &txn,
                &channel,
                "",
                true,
                None,
                1, // num_cpus::get(),
                self.salt.unwrap_or(0),
            )?;
        } else {
            for p in self.partial_paths.iter() {
                libpijul::output::output_repository_no_pending(
                    &repo.working_copy,
                    &repo.changes,
                    &txn,
                    &channel,
                    p,
                    true,
                    None,
                    1, // num_cpus::get(),
                    self.salt.unwrap_or(0),
                )?;
            }
        }