attic_cache: String,

            &config.config.attic_cache,

    attic_cache: &str,

        cmd.arg("push").arg("coturnix");

        cmd.arg("push").arg(attic_cache);

            if let Some(ref status) = status {
                status_tx.send(Some((status.finished, status.code)));
                debug!("STATUS {:?}", status);
                use crate::db::jobs::dsl as jobs;
                diesel::update(jobs::jobs.find(job))
                    .set((
                        jobs::status.eq(status.code),
                        jobs::ended.eq(status.finished),
                    ))
                    .execute(db)
                    .await
                    .unwrap();
            }

                let (mut status_tx, _status_rx) = tokio::sync::watch::channel(None::<i32>);
                let (_kill_tx, mut kill_rx) = tokio::sync::oneshot::channel();
                for (script, s) in status.results.iter() {
                    let mut cmd = tokio::process::Command::new("nix-store");
                    cmd.arg("-r").arg(&s);
                    let cmd = cmd
                        .stderr(Stdio::piped())
                        .stdout(Stdio::piped())
                        .stdin(Stdio::null())
                        .spawn()

                if status.code != Some(0) {
                    status_tx
                        .send(Some((status.finished, status.code)))

                    ci::dump_cmd(cmd, &mut files, &mut kill_rx).await.unwrap();
                }
                for (script, s) in status.results.iter() {
                    debug!("launching {:?} {:?}", s, script);
                    let cmd = tokio::process::Command::new(format!("{}/bin/{script}", s.display()))
                        .stderr(Stdio::piped())
                        .stdout(Stdio::piped())
                        .stdin(Stdio::null())
                        .spawn()

                    debug!("STATUS {:?}", status);
                    use crate::db::jobs::dsl as jobs;
                    diesel::update(jobs::jobs.find(job))
                        .set((
                            jobs::status.eq(status.code),
                            jobs::ended.eq(status.finished),
                        ))
                        .execute(db)
                        .await

                    ci::dump_cmd(cmd, &mut files, &mut kill_rx).await.unwrap();

                } else {
                    let (_kill_tx, mut kill_rx) = tokio::sync::oneshot::channel();
                    for (script, s) in status.results.iter() {
                        let mut cmd = tokio::process::Command::new("nix-store");
                        cmd.arg("-r").arg(&s);
                        let cmd = cmd
                            .stderr(Stdio::piped())
                            .stdout(Stdio::piped())
                            .stdin(Stdio::null())
                            .spawn()
                            .unwrap();
                        ci::dump_cmd(cmd, &mut files, &mut kill_rx).await.unwrap();
                    }
                    for (n, (script, s)) in status.results.iter().enumerate() {
                        debug!("launching {:?} {:?}", s, script);
                        let cmd =
                            tokio::process::Command::new(format!("{}/bin/{script}", s.display()))
                                .stderr(Stdio::piped())
                                .stdout(Stdio::piped())
                                .stdin(Stdio::null())
                                .spawn()
                                .unwrap();
                        let exit = ci::dump_cmd(cmd, &mut files, &mut kill_rx).await.unwrap();
                        if exit != Some(0) || n == status.results.len() - 1 {
                            let finished = chrono::Utc::now();
                            debug!("STATUS {:?}", exit);
                            status_tx.send(Some((finished, exit))).unwrap_or(());
                            use crate::db::jobs::dsl as jobs;
                            diesel::update(jobs::jobs.find(job))
                                .set((jobs::status.eq(exit), jobs::ended.eq(finished)))
                                .execute(db)
                                .await
                                .unwrap();
                            break;
                        }
                    }