final_path: PathBuf,

                    ref mut final_path,

                            let mut final_path = path.clone();

                            libpijul::changestore::filesystem::push_filename(
                                final_path,
                                &hashes[*current],
                            );

                            std::fs::rename(&path, &final_path)?;

                            std::fs::create_dir_all(&final_path.parent().unwrap())?;
                            let r = std::fs::rename(&path, &final_path);
                            libpijul::changestore::filesystem::pop_filename(final_path);
                            r?;

                                // If we're still waiting for
                                // another change.
                                debug!("before pop: {:?}", path);
                                libpijul::changestore::filesystem::pop_filename(path);
                                libpijul::changestore::filesystem::push_filename(
                                    path,
                                    &hashes[*current],
                                );
                                debug!("after pop: {:?}", path);
                                std::fs::create_dir_all(&path.parent().unwrap())?;
                                path.set_extension("tmp");
                                debug!("creating file {:?}", path);

                                // If we're still waiting for another
                                // change.

        let mut path = changes_dir.clone();
        std::fs::create_dir_all(&path.parent().unwrap())?;
        path.set_extension("tmp");

        let path = changes_dir.join("tmp");
        std::fs::create_dir_all(&changes_dir)?;

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

            final_path: changes_dir.clone(),

        while let Some(c) = c.recv().await {
            if let State::Changes { ref mut hashes, .. } = *self.state.lock().await {
                hashes.push(c);
            }
            debug!("download_change {:?} {:?}", c, full);
            if full {
                self.c
                    .data(format!("change {}\n", c.to_base32()).as_bytes())
                    .await?;
            } else {
                self.c
                    .data(format!("partial {}\n", c.to_base32()).as_bytes())
                    .await?;
            }
            len += 1;
        }

        while let Some(_hash) = recv.recv().await {
            debug!("received hash {:?}", _hash);
            if let Some(ref mut progress) = *PROGRESS.lock().await {
                progress.inc(1);
            }
            if let Some(ref mut sender) = sender {
                if sender.send(_hash).await.is_err() {

        let mut dropped = false;
        loop {
            tokio::select! {
                x = recv.recv() => {
                    let hash = if let Some(hash) = x {
                        debug!("received hash {:?}", hash);
                        hash
                    } else {
                        debug!("finished");
                        break
                    };

                        progress.abandon();

                        progress.inc(1);

                    break;

                    if let Some(ref mut sender) = sender {
                        if sender.send(hash).await.is_err() {
                            if let Some(ref mut progress) = *PROGRESS.lock().await {
                                progress.abandon();
                            }
                            break;
                        }
                    }
                }
                x = c.recv(), if !dropped => {
                    let c = if let Some(c) = x {
                        c
                    } else {
                        debug!("other end dropped");
                        dropped = true;
                        if len == 0 {
                            break
                        } else {
                            continue
                        }
                    };
                    if let State::Changes { ref mut hashes, .. } = *self.state.lock().await {
                        hashes.push(c);
                    }
                    debug!("download_change {:?} {:?}", c, full);
                    if full {
                        self.c
                            .data(format!("change {}\n", c.to_base32()).as_bytes())
                            .await?;
                    } else {
                        self.c
                            .data(format!("partial {}\n", c.to_base32()).as_bytes())
                            .await?;
                    }
                    if let Some(ref mut p) = *PROGRESS.lock().await {
                        p.inc_length(1)
                    }
                    len += 1;

        std::mem::drop(hash_send);