tokio::sync::watch::Receiver<std::option::Option<i32>>,

                    tokio::sync::watch::Receiver<std::option::Option<Status>>,

    let s =
        tokio::fs::read_to_string(&config.config.ci_path.join(&format!("{}.status", job))).await?;
    Ok(Json(serde_json::from_str(&s)?))

    if let Some((_, job)) = config.jobs.lock().unwrap().get(&job) {
        if let Some(s) = &*job.borrow() {
            return Ok(Json(s.clone()));
        }
    }
    Err(Error::NotFound)

            status_tx,

        let (code, results) = result?;
        debug!("code = {:?} {:?}", code, results);
        tokio::fs::write(
            config.config.ci_path.join(&format!("{}.status", t.id)),
            serde_json::to_string(&Status {

        if let Ok((code, results)) = result {
            let status = Status {

            })
            .unwrap(),
        )
        .await?;

            };
            status_tx.send(Some(status)).unwrap();
        } else {
            let status = Status {
                code: None,
                results: HashMap::new(),
                finished: chrono::Utc::now(),
            };
            status_tx.send(Some(status)).unwrap();
        }

    mut status_tx: tokio::sync::watch::Sender<Option<i32>>,

    let code = dump_cmd(cmd, &mut files, &mut kill_rx, &mut status_tx).await?;

    let code = dump_cmd(cmd, &mut files, &mut kill_rx).await?;

        Ok((
            dump_cmd(cmd, &mut files, &mut kill_rx, &mut status_tx).await?,
            result,
        ))

        Ok((dump_cmd(cmd, &mut files, &mut kill_rx).await?, result))

#[derive(Debug, Serialize, Deserialize)]

#[derive(Clone, Debug, Serialize, Deserialize)]

    status_tx: &mut tokio::sync::watch::Sender<Option<i32>>,

            status_tx.send(code).unwrap();

        let status = if let reqwest::StatusCode::OK = status.status() {

        let code = status.status();
        let status = if let reqwest::StatusCode::OK = code {

        } else if let reqwest::StatusCode::NOT_FOUND = code {
            use crate::db::jobs::dsl as jobs;
            diesel::update(jobs::jobs.find(job))
                .set((
                    jobs::status.eq(None::<i32>),
                    jobs::ended.eq(chrono::Utc::now()),
                ))
                .execute(db)
                .await
                .unwrap();
            break;

            let (mut status_tx, _status_rx) = tokio::sync::watch::channel(None);

            let (mut status_tx, _status_rx) = tokio::sync::watch::channel(None::<i32>);

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

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

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

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

            crate::replication::get_config_state(&config.repo_locks, repo, channel)

            crate::replication::get_config_state(&config.repo_locks, repo, channel.clone())

                channel,