use log::{debug, error};

use log::{debug, error, trace};

    let mut f = std::fs::File::create(&path_)?;

    let mut f = tokio::fs::File::create(&path_).await?;

    loop {

    let (send, mut recv) = tokio::sync::mpsc::channel::<Option<bytes::Bytes>>(100);
    let t = tokio::spawn(async move {
        while let Some(chunk) = recv.recv().await {
            match chunk {
                Some(chunk) => {
                    trace!("writing {:?}", chunk.len());
                    use tokio::io::AsyncWriteExt;
                    f.write_all(&chunk).await?;
                }
                None => {
                    f.set_len(0).await?;
                }
            }
        }
        Ok::<_, std::io::Error>(())
    });
    let mut done = false;
    while !done {

            f.set_len(0)?;

            send.send(None).await?;

            bail!("HTTP error {:?}", res.status())

            tokio::time::sleep(std::time::Duration::from_secs_f64(delay)).await;
            send.send(None).await?;
            delay *= 2.;
            continue;

        let done = loop {

        while !done {

                Ok(Some(chunk)) => {
                    debug!("writing {:?}", chunk.len());
                    f.write_all(&chunk)?;
                }
                Ok(None) => break true,
                Err(_) => {
                    error!("Error while downloading {:?}, retrying", url);

                Ok(Some(chunk)) => send.send(Some(chunk)).await?,
                Ok(None) => done = true,
                Err(e) => {
                    debug!("error {:?}", e);
                    error!("Error while downloading {:?} from {:?}, retrying", c32, url);
                    send.send(None).await?;

                    break false;

                    break;

        };
        if done {
            std::fs::rename(&path_, &path_.with_extension("change"))?;
            break;

    std::mem::drop(send);
    t.await??;
    if done {
        std::fs::rename(&path_, &path_.with_extension("change"))?;
    }

tokio = { version = "1.0", features = [ "rt-multi-thread", "macros", "sync" ] }

tokio = { version = "1.0", features = [ "rt-multi-thread", "macros", "sync", "fs" ] }

bytes = "1.0"

 "bytes",