improvements

Author: ideeockus

Cargo.lock

@@ -5,15 +5,16 @@ members = [
 ]
 
 [package]
-name = "ryemage"
+name = "ryemage_bot"
 version = "0.1.0"
 edition = "2021"
 authors = ["ideeockus"]
 
 [dependencies]
 teloxide = { version = "0.12", features = ["macros"] }
 log = "0.4"
-pretty_env_logger = "0.5.0"
+#pretty_env_logger = "0.5.0"
+env_logger = "0.10"
 tokio = { version = "1.31", features = ["full"] }
 tg_controller = { path="tg_controller" }
 

Cargo.toml

@@ -0,0 +1,39 @@
+FROM ekidd/rust-musl-builder:stable as builder
+
+RUN USER=root cargo new --bin ryemage_bot
+WORKDIR ./ryemage_bot
+COPY ./Cargo.lock ./Cargo.lock
+COPY ./Cargo.toml ./Cargo.toml
+RUN cargo build --release
+RUN rm src/*.rs
+
+ADD . ./
+
+RUN rm ./target/x86_64-unknown-linux-musl/release/deps/ryemage_bot*
+RUN cargo build --release
+
+
+FROM alpine:latest
+
+ARG APP=/opt/
+
+#EXPOSE 8000
+
+#ENV TZ=Etc/UTC \
+#    APP_USER=appuser
+#
+#RUN addgroup -S $APP_USER \
+#    && adduser -S -g $APP_USER $APP_USER
+
+RUN apk update \
+    && apk add --no-cache ca-certificates tzdata \
+    && rm -rf /var/cache/apk/*
+
+COPY --from=builder /home/rust/src/ryemage_bot/target/x86_64-unknown-linux-musl/release/ryemage_bot ${APP}/ryemage_bot
+
+#RUN chown -R $APP_USER:$APP_USER ${APP}
+
+#USER $APP_USER
+WORKDIR ${APP}
+
+CMD ["./ryemage_bot"]

Dockerfile

@@ -15,6 +15,7 @@ rstar = "0.11"
 log = "0.4"
 #pretty_env_logger = "0.5.0"
 #tokio = { version = "1.31", features = ["full"] }
+memmap2 = "0.7"
 
 [lib]
 name = "image_processing"

image_processing/Cargo.toml

@@ -8,7 +8,7 @@ use log::{debug, info};
 use crate::errors::{ImageProcessingError, ImageProcessingResult};
 use crate::palette_extraction::{create_lab_palette_mapper, create_rgb_palette_mapper, create_swap_palette_mapper};
 use crate::palette_operations::PaletteOperations;
-use crate::utils::load_image_from_file;
+use crate::utils::{load_image_from_file, mmap_image_from_file};
 
 mod palette_extraction;
 mod errors;
@@ -48,24 +48,31 @@ pub fn perform_action_on_files(
     let start = SystemTime::now();
     debug!("start perform actions on files");
 
-    let palette_image = load_image_from_file(palette_image)?;
-    let img_to_process = load_image_from_file(img_to_process)?;
+    let palette_image = mmap_image_from_file(palette_image)?;
+    // let palette_image = load_image_from_file(palette_image)?;
+    debug!("palette image loaded");
+    let img_to_process = mmap_image_from_file(img_to_process)?;
+    // let img_to_process = load_image_from_file(img_to_process)?;
+    debug!("image to process loaded");
 
     let processed_image = match mode {
         PaletteMapperMode::SimpleLab => {
             let color_mapper = create_lab_palette_mapper(palette_image, DEFAULT_QUANTITY);
+            debug!("palette extracted");
             let mut img_to_process = img_to_process.to_rgb8();
             img_to_process.apply_palette_to_image(color_mapper);
             img_to_process
         }
         PaletteMapperMode::SimpleRgb => {
             let color_mapper = create_rgb_palette_mapper(palette_image, DEFAULT_QUANTITY);
+            debug!("palette extracted");
             let mut img_to_process = img_to_process.to_rgb8();
             img_to_process.apply_palette_to_image(color_mapper);
             img_to_process
         }
         PaletteMapperMode::RgbDither => {
             let color_mapper = create_rgb_palette_mapper(palette_image, DEFAULT_QUANTITY);
+            debug!("palette extracted");
             let mut img_to_process = img_to_process.to_rgb8();
             img_to_process.dither_with_palette(color_mapper);
             img_to_process
@@ -74,6 +81,7 @@ pub fn perform_action_on_files(
         PaletteMapperMode::RgbSwap => {
             let color_mapper =
                 create_swap_palette_mapper(&img_to_process, &palette_image, DEFAULT_QUANTITY);
+            debug!("palette extracted");
             let mut img_to_process = img_to_process.to_rgb8();
             img_to_process.apply_palette_to_image(color_mapper);
             img_to_process
@@ -84,6 +92,7 @@ pub fn perform_action_on_files(
             return Err(ImageProcessingError::UnsupportedMode);
         }
     };
+    debug!("image processing finished");
 
     let result = Vec::with_capacity(processed_image.len());
     let mut result = Cursor::new(result);

image_processing/src/lib.rs

@@ -5,7 +5,8 @@ use std::{cmp, io};
 
 use image::imageops::FilterType;
 use image::io::Reader as ImageReader;
-use image::DynamicImage;
+use image::{DynamicImage, EncodableLayout};
+use log::debug;
 
 const IMAGE_SIZE_LIMIT: (u32, u32) = (1280, 1280);
 // const IMAGE_SIZE_LIMIT: (u32, u32) = (512, 512);
@@ -35,17 +36,35 @@ pub fn downscale_to_size(
     None
 }
 
+#[allow(unused)]
 pub fn load_image_from_file<P>(path: P) -> io::Result<DynamicImage>
-where
-    P: AsRef<Path>,
+    where
+        P: AsRef<Path>,
 {
     let fd = File::open(path)?;
     let file_size = fd.metadata().map(|m| m.len()).ok();
-    println!("file size is {:?}", file_size);
+    debug!("file size is {:?}", file_size);
 
     load_image_from_unknown_reader(BufReader::new(fd), file_size)
 }
 
+#[allow(unused)]
+pub fn mmap_image_from_file<P>(path: P) -> io::Result<DynamicImage>
+    where
+        P: AsRef<Path>,
+{
+    use memmap2::Mmap;
+
+    let fd = File::open(path)?;
+    let file_size = fd.metadata().map(|m| m.len()).ok();
+    debug!("file size is {:?}", file_size);
+
+    let file_mmap = unsafe { Mmap::map(&fd)? };
+
+
+    load_image_from_unknown_reader(BufReader::new(file_mmap.as_bytes()), file_size)
+}
+
 pub fn load_image_from_unknown_reader(
     mut reader: impl BufRead,
     size: Option<u64>,
@@ -75,9 +94,9 @@ pub fn load_image_from_unknown_reader(
 
 #[allow(unused)]
 pub fn save_image<P, B>(path: P, processed_image: B) -> io::Result<()>
-where
-    P: AsRef<Path>,
-    B: AsRef<[u8]>,
+    where
+        P: AsRef<Path>,
+        B: AsRef<[u8]>,
 {
     let mut save_file = File::create(path)?;
     save_file.write_all(processed_image.as_ref())

image_processing/src/utils.rs

@@ -1,8 +1,19 @@
-use pretty_env_logger;
+use std::io::Write;
+
+use env_logger;
+use env_logger::{Builder, TimestampPrecision};
+use log::LevelFilter;
+
 use tg_controller::run_polling;
 
 #[tokio::main]
 async fn main() {
-    pretty_env_logger::init();
+    Builder::new()
+        .filter_level(LevelFilter::Trace)
+        // .format(|buf, record| writeln!(buf, "{} - {}", record.level(), record.args()))
+        // .filter(Some("ryemage_bot"), LevelFilter::Trace)
+        .format_timestamp(Some(TimestampPrecision::Nanos))
+        .init();
+
     run_polling().await;
 }

src/main.rs

@@ -15,4 +15,6 @@ teloxide = { version = "0.12", features = ["macros"] }
 log = "0.4"
 pretty_env_logger = "0.5.0"
 tokio = { version = "1.31", features = ["full"] }
+rayon = "1.7"
+
 image_processing = { path="../image_processing" }

tg_controller/Cargo.toml

@@ -1,13 +1,19 @@
+use std::sync::atomic::{AtomicUsize, Ordering};
+
 use log::{debug, error};
 use teloxide::prelude::*;
 use teloxide::types::{ChatAction, InputFile, ParseMode};
 
 use image_processing::perform_action_on_files;
+
 use crate::{get_downloads_dir, State};
 use crate::handlers::{download_file_by_id, HandlerResult, log_request, mode_from_mode_name, MyDialogue};
 use crate::keyboards::*;
 use crate::ryemage_settings::UserSettings;
 
+static GLOBAL_USER_COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+
 pub async fn handle_base_action(
     bot: Bot,
     dialogue: MyDialogue,
@@ -109,7 +115,7 @@ pub async fn handle_palette_image(
                 msg.chat.id,
                 "My current state - waiting picture to palette extraction",
             )
-            .await?;
+                .await?;
         }
     }
 
@@ -144,7 +150,7 @@ pub async fn handle_process_mode(
                     q.from.id,
                     "Hmmm. Did you press button with sign \"Build Palette\"?",
                 )
-                .await?;
+                    .await?;
             }
 
             if let Some(msg) = q.message {
@@ -161,18 +167,18 @@ pub async fn handle_process_mode(
                 q.from.id,
                 format!("Mode {mode} in development stage. Try a bit later.."),
             )
-            .await?;
+                .await?;
             bot.send_message(
                 q.from.id,
                 format!("I see you have uploaded file {process_file_id} and have palette"),
             )
-            .await?;
+                .await?;
         }
-        Some(mode) => {
+        Some(mode_str) => {
             let palette_file_name = get_downloads_dir().join(palette_file_id);
             let process_file_name = get_downloads_dir().join(process_file_id);
 
-            let mode = match mode_from_mode_name(mode) {
+            let mode = match mode_from_mode_name(mode_str) {
                 None => {
                     bot.send_message(q.from.id, "Unknown mode, contact the developer")
                         .await?;
@@ -181,11 +187,15 @@ pub async fn handle_process_mode(
                 Some(mode) => mode,
             };
 
+            // todo run in thread pool
             let processed = perform_action_on_files(&palette_file_name, &process_file_name, mode);
+            // rayon::spawn();
 
             match processed {
                 Ok(v) => {
-                    bot.send_photo(q.from.id, InputFile::memory(v)).await?;
+                    let mut message = bot.send_photo(q.from.id, InputFile::memory(v));
+                    message.caption = Some(mode_str.to_string());
+                    message.await?;
                 }
                 Err(err) => {
                     error!("Image processing error {}", err);
@@ -194,7 +204,7 @@ pub async fn handle_process_mode(
                         q.from.id,
                         "Error occurred during image processing. Please contact the developer",
                     )
-                    .await?;
+                        .await?;
                 }
             }
         }
@@ -229,11 +239,14 @@ pub async fn view_settings(
                 .await?;
         }
         Some(USER_GUIDE) => {
-            bot.send_message(
-                msg.chat.id,
-                "There is nothing here. Wait for the rye release.",
-            )
-            .await?;
+            let mut message = bot.send_message(msg.chat.id, BOT_HELP_TEXT_MD);
+            message.parse_mode = Some(ParseMode::MarkdownV2);
+            message.await?;
+            // bot.send_message(
+            //     msg.chat.id,
+            //     "There is nothing here. Wait for the rye release.",
+            // )
+            //     .await?;
         }
         Some(THIRD_BUTTON) => {
             bot.send_message(msg.chat.id, "42 - 3 = 20").await?;
@@ -243,7 +256,7 @@ pub async fn view_settings(
                 msg.chat.id,
                 "It would be better if you pressed the third button than what you are doing now",
             )
-            .await?;
+                .await?;
         }
     }