slavaqq / rust_hello_world Goto Github PK

let address = chat::Address::parse_arguments();

lazy_static! {
    static ref REGISTRY: Registry = Registry::new();
    static ref MESSAGE_COUNTER: Counter =
        Counter::new("message_counter", "counts number of messages send")
            .expect("Counter metrics init failed!");
    static ref USER_COUNTER: Gauge = Gauge::new("user_counter", "counts number of connected users")
        .expect("Gauge metrics init failed!");
}

fn log_broadcasting(
    message: &Message,
    sender_addr: &std::net::SocketAddr,
    receiver_addr: &std::net::SocketAddr,
) {
    if log_enabled!(Level::Debug) {
        debug!(
            "Broadcasting message from client {:?} to client {:?} ({:?}).",
            sender_addr, receiver_addr, message
        );
    } else {
        info!(
            "Broadcasting message from client {:?} to client {:?}.",
            sender_addr, receiver_addr
        );
    };
}

log::debug!(
    "Broadcasting message from client {:?} to client {:?} ({:?}).",
    sender_addr, receiver_addr, message
);
log::info!(
    "Broadcasting message from client {:?} to client {:?}.",
    sender_addr, receiver_addr
);

async fn run_server() -> Result<()> {
    // ...
    loop {
        let Ok((stream, addr)) = listener.accept().await else {
            error!("Failed to accept connection!");
            continue;
        };
        // ...
    }
}

async fn init_db() -> Result<SqlitePool> {
    if !Sqlite::database_exists(DB).await.unwrap_or(false) {
        info!("Creating database: {}", DB);
        Sqlite::create_database(DB)
            .await
            .context("Creating database error!")?;
    }
    // ...
}

async fn reading_loop(mut stream: OwnedReadHalf) -> Result<()> {
    loop {
        let message = chat::Message::read(&mut stream).await?;
        if let Err(err_msg) = handle_message(message).await {
            eprintln!("Message handling error: {:?}", err_msg);
        };
        tokio::spawn(async {
            meow().await.unwrap_or_else(|err_msg| eprintln!("Sound error {:?}", err_msg))
        });
    }
}

async fn meow() -> Result<()> {
    let (_stream, stream_handle) = OutputStream::try_default()?;
    let file = std::fs::File::open(SOUND_FILE)?; // should also replace with tokio::fs::File
    let source = Decoder::new(std::io::BufReader::new(file))?;
    stream_handle.play_raw(source.convert_samples())?;
    tokio::time::sleep(std::time::Duration::from_secs(2)).await;
    Ok(())
}