hoy 0.1.1

Real-time messaging TUI app
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use std::net::{IpAddr, Ipv4Addr, SocketAddr};

use clap::Parser;
use hoy_core::memory::InMemoryStore;
use hoy_core::store::{RoomName, ServerStore, StoredMessage};
use hoy_net::client::test_client::run_test_client;
use hoy_net::server::core::run_server;

/// Hoy command-line interface.
#[derive(Debug, Parser)]
#[command(
    name = "hoy",
    about = "A TUI real time messaging app.",
    version,
    propagate_version = true,
    after_help = r#"Example:
  # Start server
  hoy -s

  # Connect with a client in another shell
  hoy -u bruce_lee

For more info, see https://gitlab.com/byacrates/hoy
"#
)]
struct Cli {
    /// Run in server mode instead of client mode
    #[arg(short = 's', long = "server", default_value_t = false)]
    server: bool,

    /// Port to bind the server or connect the client to
    #[arg(short = 'p', long = "port", default_value_t = 7777)]
    port: u16,

    /// Server address to connect to. [default: localhost]
    #[arg(short = 'a', long = "address")]
    ipv4: Option<Ipv4Addr>,

    /// Client username (required in client mode)
    #[arg(short = 'u', long = "username")]
    username: Option<String>,
}

/**
 * Entry point for the hoy binary.
 *
 * Parses CLI arguments and runs either the server or the test client.
 *
 * # Errors
 * Returns a boxed error if the server or client encounters a fatal failure.
 */
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args = Cli::parse();
    let address: SocketAddr;

    if let Some(addr) = args.ipv4 {
        address = SocketAddr::new(IpAddr::V4(addr), args.port);
    } else {
        address = SocketAddr::new(std::net::IpAddr::V4(Ipv4Addr::LOCALHOST), args.port);
    }

    let mut store = InMemoryStore::new();
    let room1 = RoomName::new("test")?;
    let room2 = RoomName::new(RoomName::GENERAL).expect("hardcoded name is valid");
    let from = String::from("bob");
    let messages: Vec<StoredMessage> = vec![
        StoredMessage {
            room: room1.clone(),
            from: from.clone(),
            text: String::from("akafuka1"),
        },
        StoredMessage {
            room: room2.clone(),
            from: from.clone(),
            text: String::from("akafuka2"),
        },
        StoredMessage {
            room: room1.clone(),
            from: from.clone(),
            text: String::from("akafuka3"),
        },
    ];

    store.ensure_room(&room1)?;
    store.ensure_room(&room2)?;
    for message in messages {
        store.append_message(message)?;
    }

    if args.server {
        run_server(address, store).await?;
    } else {
        let Some(username) = args.username else {
            eprintln!("No client username provided.");
            return Ok(());
        };
        run_test_client(address, username.clone()).await?;
    }

    Ok(())
}