fix branch matching

Signed-off-by: eternal-flame-AD <yume@yumechi.jp>

yume-mods/misskey-auto-deploy/src/lib.rs

@@ -1,6 +1,10 @@
 use std::{collections::HashMap, fs::OpenOptions, path::PathBuf, process::Stdio, sync::Arc};
 
-use axum::{extract::{Query, State, Json}, http::{HeaderMap, StatusCode}, response::{IntoResponse, Response}};
+use axum::{
+    extract::{Json, Query, State},
+    http::{HeaderMap, StatusCode},
+    response::{IntoResponse, Response},
+};
 use chrono::NaiveDateTime;
 use libc::SIGTERM;
 use tokio::{process::Command, sync::RwLock};
@@ -80,10 +84,7 @@ pub struct GetStatusQuery {
     pub branch: Option<String>,
 }
 
-
+fn require_bearer(bcrypted: &str, headers: &HeaderMap) -> Result<(), ApiError> {
-fn require_bearer(
-    bcrypted: &str,
-    headers: &HeaderMap) -> Result<(), ApiError> {
     let bearer = headers
         .get("authorization")
         .ok_or_else(|| ApiError {
@@ -95,7 +96,9 @@ fn require_bearer(
             code: 400,
             message: "Invalid Authorization header".to_string(),
         })?;
-    let bearer = bearer.trim_start_matches("Bearer ").trim_start_matches("bearer ");
+    let bearer = bearer
+        .trim_start_matches("Bearer ")
+        .trim_start_matches("bearer ");
 
     if !bcrypt::verify(bearer, bcrypted).map_err(|_| ApiError {
         code: 401,
@@ -110,7 +113,6 @@ fn require_bearer(
     Ok(())
 }
 
-
 impl App {
     pub async fn post_deploy(
         State(state): State<AppState>,
@@ -119,10 +121,16 @@ impl App {
     ) -> Result<StatusCode, ApiError> {
         require_bearer(&state.bearer_secret, &headers)?;
 
-        let matched_ref = state.refs.get(&payload.ref_).ok_or_else(|| ApiError {
+        let matched_ref = state
+            .refs
+            .into_iter()
+            .find(|(_, ref_state)| ref_state.config.ref_ == payload.ref_)
+            .ok_or_else(|| ApiError {
                 code: 404,
                 message: "Ref not found".to_string(),
-        })?.clone();
+            })?
+            .1
+            .clone();
 
         let mut status = matched_ref.status.write().await;
 
@@ -159,7 +167,9 @@ impl App {
             .map_err(|_| ApiError {
                 code: 500,
                 message: "Failed to wait for command".to_string(),
-            })?.success()  {
+            })?
+            .success()
+        {
             status.status = Status::Error("Failed to fetch".to_string());
             return Ok(StatusCode::OK);
         }
@@ -181,23 +191,36 @@ impl App {
             .map_err(|_| ApiError {
                 code: 500,
                 message: "Failed to wait for command".to_string(),
-            })?.success()  {
+            })?
+            .success()
+        {
             status.status = Status::Error("Failed to reset".to_string());
             return Ok(StatusCode::OK);
         }
 
-
         let mut command = Command::new("docker")
             .arg("compose")
             .arg("up")
             .arg("--detach")
             .arg("--build")
-            .args(matched_ref.config.compose_flags.as_ref().unwrap_or(&Vec::new()))
+            .args(
+                matched_ref
+                    .config
+                    .compose_flags
+                    .as_ref()
+                    .unwrap_or(&Vec::new()),
+            )
             .current_dir(matched_ref.config.working_dir.clone())
             .kill_on_drop(true)
-            .envs(matched_ref.config.env.as_ref().unwrap_or(&HashMap::new()).iter())
+            .envs(
-            .stdout(
+                matched_ref
-                match matched_ref.config.stdout.as_ref() {
+                    .config
+                    .env
+                    .as_ref()
+                    .unwrap_or(&HashMap::new())
+                    .iter(),
+            )
+            .stdout(match matched_ref.config.stdout.as_ref() {
                 Some(path) => {
                     let file = OpenOptions::new()
                         .create(true)
@@ -211,8 +234,7 @@ impl App {
                     Stdio::from(file)
                 }
                 None => Stdio::null(),
-                }
+            })
-            )
             .spawn()
             .map_err(|_| ApiError {
                 code: 500,
@@ -222,12 +244,10 @@ impl App {
         status.status = Status::Deploying;
         status.triggered = Some(chrono::Utc::now().naive_utc());
 
-        status.child_pid = command.id().ok_or_else( ||
+        status.child_pid = command.id().ok_or_else(|| ApiError {
-            ApiError {
             code: 500,
             message: "Failed to get child PID".to_string(),
-            }
+        })?;
-        )?;
 
         let matched_ref = matched_ref.clone();
         tokio::spawn(async move {
@@ -250,7 +270,6 @@ impl App {
             }
         });
 
-
         Ok(StatusCode::OK)
     }
 
@@ -273,16 +292,22 @@ impl App {
         let ref_ = match (&query.ref_, &query.branch) {
             (Some(ref_), None) => ref_.clone(),
             (None, Some(branch)) => format!("refs/heads/{}", branch),
-            _ => return Err(ApiError {
+            _ => {
+                return Err(ApiError {
                     code: 400,
                     message: "Either ref or branch must be specified".to_string(),
-            }),
+                })
+            }
         };
 
-        let matched_ref = state.refs.get(&ref_).ok_or_else(|| ApiError {
+        let matched_ref = state
+            .refs
+            .get(&ref_)
+            .ok_or_else(|| ApiError {
                 code: 404,
                 message: "Ref not found".to_string(),
-        })?.clone();
+            })?
+            .clone();
 
         let status = matched_ref.status.read().await;
 

yume-mods/misskey-auto-deploy/src/main.rs

@@ -1,7 +1,7 @@
-use std::{collections::HashMap, sync::Arc};
 use axum::Router;
-use tokio::{net::TcpListener, sync::RwLock};
 use clap::Parser;
+use std::{collections::HashMap, sync::Arc};
+use tokio::{net::TcpListener, sync::RwLock};
 
 use misskey_auto_deploy::{App, AppState, RefConfig, RefState, RefStatus, Status};
 
@@ -13,7 +13,6 @@ struct Args {
     config: String,
 }
 
-
 #[derive(Debug, serde::Deserialize)]
 pub struct Config {
     pub service: ServiceConfig,
@@ -33,8 +32,11 @@ pub struct ServiceConfig {
 
 impl From<Config> for AppState {
     fn from(val: Config) -> Self {
-        let refs = val.refs.into_iter().map(|(ref_, config)| {
+        let refs = val
-            let status = RefStatus{
+            .refs
+            .into_iter()
+            .map(|(ref_, config)| {
+                let status = RefStatus {
                     status: Status::Never,
                     last_payload: None,
                     triggered: None,
@@ -44,7 +46,8 @@ impl From<Config> for AppState {
                 let status = RwLock::new(status);
 
                 (ref_, Arc::new(RefState { config, status }))
-        }).collect();
+            })
+            .collect();
         AppState {
             bearer_secret: val.auth.secret,
             refs,
@@ -52,12 +55,13 @@ impl From<Config> for AppState {
     }
 }
 
-
 #[tokio::main]
 async fn main() {
     let args = Args::parse();
 
-    let config:Config = toml::from_str(&std::fs::read_to_string(args.config).expect("Failed to read config file")).expect("Failed to parse config file");
+    let config: Config =
+        toml::from_str(&std::fs::read_to_string(args.config).expect("Failed to read config file"))
+            .expect("Failed to parse config file");
 
     let listen = match (&args.listen, &config.service.listen) {
         (Some(listen), _) => listen.clone(),
@@ -68,14 +72,16 @@ async fn main() {
     let app_state: AppState = config.into();
 
     let app = Router::new()
-        .route("/deploy", 
+        .route(
-            axum::routing::post(App::post_deploy)
+            "/deploy",
-            .get(App::get_status)
+            axum::routing::post(App::post_deploy).get(App::get_status),
         )
         .route("/summary", axum::routing::get(App::summary))
         .with_state(app_state);
 
-    let listener = TcpListener::bind(listen).await.expect("Failed to bind listener");
+    let listener = TcpListener::bind(listen)
+        .await
+        .expect("Failed to bind listener");
 
     axum::serve(listener, app).await.unwrap();
 }