feat: support optimize images

apps/recorder/src/app/builder.rs

@@ -21,6 +21,9 @@ pub struct MainCliArgs {
     /// Explicit environment
     #[arg(short, long)]
     environment: Option<Environment>,
+
+    #[arg(long)]
+    graceful_shutdown: Option<bool>,
 }
 
 pub struct AppBuilder {
@@ -28,6 +31,7 @@ pub struct AppBuilder {
     config_file: Option<String>,
     working_dir: String,
     environment: Environment,
+    pub graceful_shutdown: bool,
 }
 
 impl AppBuilder {
@@ -61,7 +65,8 @@ impl AppBuilder {
         builder = builder
             .config_file(args.config_file)
             .dotenv_file(args.dotenv_file)
-            .environment(environment);
+            .environment(environment)
+            .graceful_shutdown(args.graceful_shutdown.unwrap_or(true));
 
         Ok(builder)
     }
@@ -118,6 +123,12 @@ impl AppBuilder {
         ret
     }
 
+    pub fn graceful_shutdown(self, graceful_shutdown: bool) -> Self {
+        let mut ret = self;
+        ret.graceful_shutdown = graceful_shutdown;
+        ret
+    }
+
     pub fn dotenv_file(self, dotenv_file: Option<String>) -> Self {
         let mut ret = self;
         ret.dotenv_file = dotenv_file;
@@ -141,6 +152,7 @@ impl Default for AppBuilder {
             dotenv_file: None,
             config_file: None,
             working_dir: String::from("."),
+            graceful_shutdown: true,
         }
     }
 }

apps/recorder/src/app/config/default_mixin.toml

@@ -11,6 +11,7 @@ leaky_bucket_initial_tokens = 0
 leaky_bucket_refill_tokens = 1
 leaky_bucket_refill_interval = 500
 
+
 [mikan.http_client.proxy]
 
 [mikan.http_client.proxy.headers]
@@ -26,3 +27,5 @@ complexity_limit = inf
 [task]
 
 [message]
+
+[media]

apps/recorder/src/app/config/mod.rs

@@ -11,8 +11,8 @@ use super::env::Environment;
 use crate::{
     auth::AuthConfig, cache::CacheConfig, crypto::CryptoConfig, database::DatabaseConfig,
     errors::RecorderResult, extract::mikan::MikanConfig, graphql::GraphQLConfig,
-    logger::LoggerConfig, message::MessageConfig, storage::StorageConfig, task::TaskConfig,
-    web::WebServerConfig,
+    logger::LoggerConfig, media::MediaConfig, message::MessageConfig, storage::StorageConfig,
+    task::TaskConfig, web::WebServerConfig,
 };
 
 const DEFAULT_CONFIG_MIXIN: &str = include_str!("./default_mixin.toml");
@@ -27,6 +27,7 @@ pub struct AppConfig {
     pub mikan: MikanConfig,
     pub crypto: CryptoConfig,
     pub graphql: GraphQLConfig,
+    pub media: MediaConfig,
     pub logger: LoggerConfig,
     pub database: DatabaseConfig,
     pub task: TaskConfig,

apps/recorder/src/app/context.rs

@@ -6,7 +6,8 @@ use super::{Environment, config::AppConfig};
 use crate::{
     auth::AuthService, cache::CacheService, crypto::CryptoService, database::DatabaseService,
     errors::RecorderResult, extract::mikan::MikanClient, graphql::GraphQLService,
-    logger::LoggerService, message::MessageService, storage::StorageService, task::TaskService,
+    logger::LoggerService, media::MediaService, message::MessageService, storage::StorageService,
+    task::TaskService,
 };
 
 pub trait AppContextTrait: Send + Sync + Debug {
@@ -23,6 +24,7 @@ pub trait AppContextTrait: Send + Sync + Debug {
     fn crypto(&self) -> &CryptoService;
     fn task(&self) -> &TaskService;
     fn message(&self) -> &MessageService;
+    fn media(&self) -> &MediaService;
 }
 
 pub struct AppContext {
@@ -37,6 +39,7 @@ pub struct AppContext {
     working_dir: String,
     environment: Environment,
     message: MessageService,
+    media: MediaService,
     task: OnceCell<TaskService>,
     graphql: OnceCell<GraphQLService>,
 }
@@ -57,6 +60,7 @@ impl AppContext {
         let auth = AuthService::from_conf(config.auth).await?;
         let mikan = MikanClient::from_config(config.mikan).await?;
         let crypto = CryptoService::from_config(config.crypto).await?;
+        let media = MediaService::from_config(config.media).await?;
 
         let ctx = Arc::new(AppContext {
             config: config_cloned,
@@ -70,6 +74,7 @@ impl AppContext {
             working_dir: working_dir.to_string(),
             crypto,
             message,
+            media,
             task: OnceCell::new(),
             graphql: OnceCell::new(),
         });
@@ -136,4 +141,7 @@ impl AppContextTrait for AppContext {
     fn message(&self) -> &MessageService {
         &self.message
     }
+    fn media(&self) -> &MediaService {
+        &self.media
+    }
 }

apps/recorder/src/app/core.rs

@@ -6,7 +6,6 @@ use tracing::instrument;
 
 use super::{builder::AppBuilder, context::AppContextTrait};
 use crate::{
-    app::Environment,
     errors::{RecorderError, RecorderResult},
     web::{
         controller::{self, core::ControllerTrait},
@@ -76,22 +75,30 @@ impl App {
             .into_make_service_with_connect_info::<SocketAddr>();
 
         let task = context.task();
+
+        let graceful_shutdown = self.builder.graceful_shutdown;
+
         tokio::try_join!(
             async {
-                axum::serve(listener, router)
-                    .with_graceful_shutdown(async move {
-                        Self::shutdown_signal().await;
-                        tracing::info!("axum shutting down...");
-                    })
-                    .await?;
+                let axum_serve = axum::serve(listener, router);
+
+                if graceful_shutdown {
+                    axum_serve
+                        .with_graceful_shutdown(async move {
+                            Self::shutdown_signal().await;
+                            tracing::info!("axum shutting down...");
+                        })
+                        .await?;
+                } else {
+                    axum_serve.await?;
+                }
+
                 Ok::<(), RecorderError>(())
             },
             async {
                 {
                     let monitor = task.setup_monitor().await?;
-                    if matches!(context.environment(), Environment::Development) {
-                        monitor.run().await?;
-                    } else {
+                    if graceful_shutdown {
                         monitor
                             .run_with_signal(async move {
                                 Self::shutdown_signal().await;
@@ -99,6 +106,8 @@ impl App {
                                 Ok(())
                             })
                             .await?;
+                    } else {
+                        monitor.run().await?;
                     }
                 }