extract::{Path, State},

    extract::{MatchedPath, Path, Request, State},

use tower_http::trace::TraceLayer;

        .route("/kill/{job}", post(kill))

        .layer(
            TraceLayer::new_for_http()
                .make_span_with(|req: &Request| {
                    let method = req.method();
                    let uri = req.uri();
                    let matched_path = req
                        .extensions()
                        .get::<MatchedPath>()
                        .map(|matched_path| matched_path.as_str());
                    tracing::debug_span!("request", %method, %uri, matched_path)
                })
                .on_failure(()),
        )

) -> Result<Json<Status>, Error> {
    if let Some((_, job)) = config.jobs.lock().unwrap().get(&job) {
        if let Some(s) = &*job.borrow() {
            return Ok(Json(s.clone()));

) -> Result<Json<Option<Status>>, Error> {
    debug!("status");
    let mut jobs = config.jobs.lock().unwrap();
    let mut closed = false;
    if let Some((kill, status)) = jobs.get_mut(&job) {
        let s = if let Some(s) = &*status.borrow_and_update() {
            Some(s.clone())
        } else {
            None
        };
        if kill.is_closed() {
            jobs.remove(&job);

        debug!("status {:?}", s);
        return Ok(Json(s));

    debug!("status not found");

// #[derive(Debug, Clone)]
// struct RepoPath {
//     path: PathBuf,
//     remove_dir: bool,
//     remove_dot: bool,
// }

    let (status_tx, status_rx) = tokio::sync::watch::channel(None);
    let (kill_tx, kill_rx) = tokio::sync::oneshot::channel();
    if let Some((k, _)) = config
        .jobs
        .lock()
        .unwrap()
        .insert(t.id, (kill_tx, status_rx))
    {
        k.send(()).unwrap_or(());
    }

        let (status_tx, status_rx) = tokio::sync::watch::channel(None);
        let (kill_tx, kill_rx) = tokio::sync::oneshot::channel();
        if let Some((k, _)) = config
            .jobs
            .lock()
            .unwrap()
            .insert(t.id, (kill_tx, status_rx))
        {
            k.send(()).unwrap_or(());
        }

            status_tx.send(Some(status)).unwrap();

            status_tx.send(Some(status)).unwrap_or(());

            status_tx.send(Some(status)).unwrap();

            status_tx.send(Some(status)).unwrap_or(());

    Ok(StatusCode::OK)
}
#[axum::debug_handler]
pub async fn kill(
    State(config): State<Config>,
    Path(job): Path<uuid::Uuid>,
) -> Result<StatusCode, Error> {
    if let Some((kill, job)) = config.jobs.lock().unwrap().get_mut(&job) {
        let k = std::mem::replace(kill, tokio::sync::oneshot::channel().0);
        k.send(()).unwrap_or(())
    }

    debug!("build");

tower-http.workspace = true

        debug!("Status: {:?} -> {:?}", job, code);

            let status: ci::Status = status.json().await.unwrap();
            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();
            Some(status)

            let status: Option<ci::Status> = status.json().await.unwrap();
            if let Some(ref status) = status {
                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();
            }
            status

                .await
                .unwrap();

                .await;
            debug!("{:?}", res);

tower-http = { version = "0.6.11", features = [ "trace", "cors", "compression-br", "compression-gzip", "compression-zstd", "compression-deflate", "fs" ] }

tower-http.workspace = true

axum-extra = "0.12.6"

axum-extra = "0.12.6"
tower-http = { version = "0.6.11", features = [ "trace", "cors", "compression-br", "compression-gzip", "compression-zstd", "compression-deflate", "fs" ] }

            name = "tower-http";
            packageId = "tower-http";
            features = [ "trace" "cors" "compression-br" "compression-gzip" "compression-zstd" "compression-deflate" "fs" ];
          }
          {

 "tower-http",