(rust) sending files via tcp

rust/src/main.rs

@@ -1,131 +1,69 @@
 #![allow(dead_code, unused)]
 
-mod log_handler;
+use std::fs::read;
 
 use chrono::{
-    DateTime, Local,
+    DateTime,
+    Local,
+};
+use clap::{
+    Args,
+    Parser,
+    Subcommand
 };
-use clap::{Args, Parser, Subcommand};
 use sqlx::{
-    database, migrate::MigrateDatabase, query, query_as, sqlite::{
+    migrate::MigrateDatabase,
+    query,
+    query_as, 
+    Row,
+    sqlite::{
         SqlitePool,
         SqlitePoolOptions,
-    }, Row, Sqlite
+    },
+    Sqlite,
+};
+use tokio::{
+    fs,
+    io::{
+        AsyncReadExt,
+        AsyncWriteExt,
+    },
+    net::{
+        TcpListener,
+        TcpStream,
+    },
+    time::{
+        Duration,
+        sleep,
+    },
 };
-
-use log_handler::{LogType, Logger};
-
-const DATABASE_URL: &str = "./test.db";
-const NAME_LOG_TABLE: &str = "logs";
-const NAME_TEST_TABLE: &str = "tests";
-
-#[derive(Parser, Debug)]
-#[clap(author, version, about, long_about=None)]
-struct Arguments {
-    /// subcommand
-    #[command(subcommand)]
-    pub action: Action,
-}
-
-#[allow(non_camel_case_types)]
-#[derive(Debug, Clone, Subcommand)]
-pub enum Action {
-    /// perform action on logs
-    #[command(subcommand)]
-    log(LogAction),
-
-    /// perform action on tests
-    #[command(subcommand)]
-    test(TestAction),
-}
-
-#[allow(non_camel_case_types)]
-#[derive(Debug, Clone, Subcommand)]
-pub enum LogAction {
-    add(LogAddArgs),
-    get(LogGetArgs),
-    remove(LogRemoveArgs),
-    show(LogShowArgs),
-}
-
-#[allow(non_camel_case_types)]
-#[derive(Debug, Clone, Subcommand)]
-pub enum TestAction {
-    add(TestArgs),
-    remove(TestArgs),
-    show,
-}
-
-#[derive(Debug, Clone, Args)]
-pub struct LogAddArgs {
-    log_type: String,
-    log_test: String,
-    log_message: String,
-}
-
-#[derive(Debug, Clone, Args)]
-pub struct LogGetArgs {
-    id: usize,
-}
-
-#[derive(Debug, Clone, Args)]
-pub struct LogRemoveArgs {
-    range_start: usize,
-    range_stop: usize,
-}
-
-#[derive(Debug, Clone, Args)]
-pub struct LogShowArgs {
-    range_start: Option<usize>,
-    range_stop: Option<usize>,
-}
-
-#[derive(Clone, Debug, Args)]
-pub struct TestArgs {
-    test_name: String,
-}
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    let args = Arguments::try_parse()?;
+    let listener = TcpListener::bind("127.0.0.1:9090").await?;
-    let logger = Logger::setup().await.unwrap();
-    let read_logger = logger.clone();
 
-    match args.action {
+    let file = fs::read("test.md").await?;
-        Action::log(subaction) => {
+
-            match subaction {
+    tokio::spawn(async move {
-                LogAction::add(args) => {
+        sleep(Duration::from_secs(2)).await;
-                    logger.add_log(LogType::from_str(&args.log_type.as_str())?, &args.log_test, &args.log_message).await.unwrap();
+
-                }
+        let mut connection = TcpStream::connect("127.0.0.1:9090").await.unwrap();
-                LogAction::get(args) => {
+        connection.write_all(&file[..]).await.unwrap();
-                    let record = logger.query_for_log(&format!("DELETE FROM logs WHERE log_id = {} RETURNING log_id, log_time, test_name, log_message;", args.id)).await.unwrap();
+    });
-                    println!("record: {:#?}", record);
+
-                }
+    let mut read_buffer = [0u8; 2<<16];
-                LogAction::remove(args) => {
+    match listener.accept().await {
-                    _ = logger.query(&format!("DELETE FROM logs WHERE log_id BETWEEN {} AND {};", args.range_start, args.range_stop)).await;
+        Ok((mut stream, address)) => {
-                }
+            println!("accepted connection request from {}", address);
-                LogAction::show(args) => {
+            let size = stream.read(&mut read_buffer).await?;
-                    // let records = read_logger.query_for_log(&format!("SELECT log_id, log_time, log_type, test_name, log_message FROM logs;")).await.unwrap();
+            fs::write("test-copy.md", &read_buffer[0..size]).await?;
-                    let records = read_logger.query_for_log(&format!("SELECT * FROM logs;")).await.unwrap();
-                    println!("records: {:#?}", records);
-                }
-            }
         }
-        Action::test(subaction) => {
+        Err(error) => {
-            match subaction {
+            println!("this is unexpected.. {}", error.to_string());
-                TestAction::add(args) => {
-                    logger.add_test(args.test_name.as_str(), Local::now()).await?;
-                }
-                TestAction::remove(args) => {
-                    logger.remove_test(args.test_name.as_str()).await?;
-                }
-                TestAction::show => {
-                    let tests = logger.get_tests(None).await?;
-                    println!("tests: {:#?}", tests);
-                }
-            }
         }
     }
 
     Ok(())
 }
+
+