From 1acb77331ba284774e38ab4c64d435d911d95d82 Mon Sep 17 00:00:00 2001 From: zegonix Date: Tue, 24 Jun 2025 19:26:51 +0200 Subject: [PATCH] (rust) PathBuf `push()` behaviour --- rust/Cargo.toml | 4 - rust/src/main.rs | 204 ++++++----------------------------------------- 2 files changed, 23 insertions(+), 185 deletions(-) diff --git a/rust/Cargo.toml b/rust/Cargo.toml index a6eacc4..b90ac66 100644 --- a/rust/Cargo.toml +++ b/rust/Cargo.toml @@ -7,11 +7,7 @@ edition = "2021" anyhow = "1.0" chrono = "0.4.41" clap = { version = "4.5.0", features = ["derive"] } -ctrlc = "3.4" dirs = "5.0.1" -sqlx = { version = "0.8", features = [ "runtime-tokio", "sqlite", "chrono" ] } thiserror = "2.0.12" tokio = { version = "1.42.0", features = ["full", "rt"] } -prost = "0.13" -proto = { path = "proto" } diff --git a/rust/src/main.rs b/rust/src/main.rs index 1e3b188..cf49cfe 100644 --- a/rust/src/main.rs +++ b/rust/src/main.rs @@ -1,198 +1,40 @@ #![allow(dead_code, unused)] -use chrono::{DateTime, Local}; -use prost::{DecodeError, EncodeError, Message}; -use proto::protest::*; -use tokio::{ +use std::{ fs, - io::{AsyncReadExt, AsyncWriteExt}, - net::{TcpListener, TcpStream}, - time::{sleep, Duration}, + path::PathBuf, }; +use dirs::config_dir; const BLOCK_SIZE: usize = 1024; const TIMEOUT_LIMIT: usize = 32; #[tokio::main] async fn main() -> anyhow::Result<()> { - let listener = TcpListener::bind("127.0.0.1:9090").await?; - let mut file = fs::read("../lorem.md").await?; - println!("filesize = {}", file.len()); + let mut path: PathBuf = match config_dir() { + Some(value) => value, + None => return Err(anyhow::Error::msg("no configuration directory for you")), + }; - tokio::spawn(async move { - let mut connection = TcpStream::connect("127.0.0.1:9090").await.unwrap(); - let blocks = if 0 == file.len() % BLOCK_SIZE { - file.len() / BLOCK_SIZE - } else { - file.len() / BLOCK_SIZE + 1 - }; - let mut index = 0; - println!("blocks = {blocks}"); - loop { - let mut buffer = vec![0u8; BLOCK_SIZE + 1024]; - let data: Vec = if file.len() > BLOCK_SIZE { - file.drain(0..BLOCK_SIZE).collect() - } else { - file.drain(..).collect() - }; - index += 1; - if index > blocks { - panic!("something went horribly wrong, index ({index}) > blocks ({blocks}), remaining filesize = {}", file.len()); - } - - println!("sending index = {}", index); - let frame = Payload { - index: index as u64, - blocks: blocks as u64, - payload: data, - }; - - let length = encode_with_length(&frame, &mut buffer).unwrap(); - _ = connection.write_all(&buffer[0..length]).await; - - if index == blocks { - break; - } - sleep(Duration::from_millis(1)).await; - } - }); - - match listener.accept().await { - Ok((mut stream, address)) => { - let mut output = Vec::::new(); - let mut buffer = [0u8; BLOCK_SIZE + 1024]; - let mut vector: Vec = Vec::new(); - let mut timeout_counter: usize = 0; - - 'receive: loop { - loop { - let num = stream.read(&mut buffer[..]).await.unwrap(); - if num != 0 { - vector.extend(buffer[0..num].iter()); - if timeout_counter > 0 { - timeout_counter -= 1; - } - break; - } - timeout_counter += 1; - if timeout_counter > TIMEOUT_LIMIT { - println!("\n\n[[ TIMEOUT ]]\n\n"); - break 'receive; - } - sleep(Duration::from_millis(100)).await; - } - let mut delimiter = prost::decode_length_delimiter(&vector[..]).unwrap(); - delimiter += prost::length_delimiter_len(delimiter); - - let payload = Payload::decode_length_delimited(&vector[0..delimiter]).unwrap(); - _ = vector.drain(0..delimiter); - - println!("-- receiving index = {}, delimiter = {}", payload.index, delimiter); - - output.extend(payload.payload.iter()); - - if payload.index == payload.blocks { - break; - } - sleep(Duration::from_millis(1)).await; - } - - _ = fs::write("./lorem-copy.md", output).await?; - } - Err(error) => { - println!("this is unexpected.. {}", error.to_string()); - } - } + check_path(&path); + path.push("navigate"); + check_path(&path); + path.push("bookmarks"); + check_path(&path); + path.push("default.toml"); + check_path(&path); Ok(()) } -async fn receive_file(stream: &mut TcpStream) -> Result, anyhow::Error> { - const BUFFER_SIZE: usize = 4096; - let mut buffer = [0u8; BUFFER_SIZE]; - let mut index_counter: usize = 0; - let mut processing_buffer = Vec::::new(); - let mut file = Vec::::new(); - let mut size: usize = 0; - - loop { - let num_bytes = stream.read(&mut buffer[..]).await?; - processing_buffer.extend(&buffer[0..num_bytes]); - if 0 == index_counter { - size = usize::from_be_bytes( - processing_buffer - .drain(0..8) - .collect::>() - .try_into() - .unwrap(), - ); - } else { - _ = processing_buffer.drain(0..8); - } - let block_size = usize::from_be_bytes( - processing_buffer - .drain(0..8) - .collect::>() - .try_into() - .unwrap(), - ); - let index = usize::from_be_bytes( - processing_buffer - .drain(0..8) - .collect::>() - .try_into() - .unwrap(), - ); - - if index_counter != index { - panic!("meh, counter = {index_counter}, index = {index}"); - } - - file.extend(processing_buffer.drain(0..block_size)); - - index_counter += 1; - if block_size >= size { - break; - } else { - size -= block_size; - } +fn check_path(path: &PathBuf) { + if path.is_dir() { + println!("[{:#?}] is a valid `DIRECTORY`", path); + } else if path.is_file() { + println!("[{:#?}] is a valid `FILE`", path); + } else if path.exists() { + println!("[{:#?}] is a valid `ENTITY`", path); + } else { + println!("[{:#?}] is `NOT` a valid path", path); } - - Ok(file) -} - -async fn send_file(stream: &mut TcpStream, mut file: Vec) -> Result<(), anyhow::Error> { - const BLOCK_SIZE: usize = 2048; - let size: usize = file.len(); - let mut remaining = size; - let mut index: usize = 0; - - while remaining > 0 { - let mut block = Vec::::new(); - let len = if remaining >= BLOCK_SIZE { - BLOCK_SIZE - } else { - remaining - }; - - block.extend(size.to_be_bytes()); - block.extend(len.to_be_bytes()); - block.extend(index.to_be_bytes()); - block.extend(file.drain(0..len)); - - stream.write(&block[..]).await?; - - remaining -= len; - index += 1; - } - - Ok(()) -} - -fn encode_with_length(message: &impl Message, buffer: &mut Vec) -> Result { - let mut length = message.encoded_len(); - length += prost::length_delimiter_len(length); - message.encode_length_delimited(&mut &mut buffer[0..length])?; - - Ok(length) }