russel 0.0.1

A simple static site builder I built for myself.
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Contains the dev command execution logic

use axum::Router;
use notify::{Config, RecommendedWatcher, RecursiveMode, Watcher};
use std::net::SocketAddr;
use std::path::Path;
use std::sync::mpsc::channel;
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::{Duration, Instant};
use tokio::sync::oneshot;
use tower_http::services::ServeDir;

use crate::error::Result;

/// Executes the 'dev' command which runs in development mode
pub async fn execute() -> Result<()> {
    println!("Running in development mode...");

    start_watch().await;

    Ok(())
}

pub async fn start_watch() {
    // Directory to watch for changes
    let watch_path = "./content";

    println!("Starting hot reload server, watching: {}", watch_path);
    println!("Press Ctrl+C to stop");

    // Create a channel for file change events
    let (file_tx, file_rx) = channel();

    // Create a watcher
    let mut watcher = RecommendedWatcher::new(file_tx, Config::default()).unwrap();

    // Start watching the directory
    watcher
        .watch(Path::new(watch_path), RecursiveMode::Recursive)
        .unwrap();

    // Channel for server shutdown
    let (shutdown_tx, _) = oneshot::channel::<()>();
    let shutdown_tx = Arc::new(Mutex::new(Some(shutdown_tx)));

    // Start the server initially
    let mut server_handle = start_server(Arc::clone(&shutdown_tx));
    let mut last_restart = Instant::now();

    // Listen for file changes
    loop {
        match file_rx.recv_timeout(Duration::from_millis(100)) {
            Ok(_) => {
                // Debounce to avoid multiple restarts for simultaneous file changes
                if last_restart.elapsed() > Duration::from_millis(500) {
                    println!("File change detected. Restarting server...");

                    // Signal the server to shut down
                    if let Some(tx) = shutdown_tx.lock().unwrap().take() {
                        let _ = tx.send(());
                    }

                    // Wait for the server thread to complete
                    if let Some(handle) = server_handle.take() {
                        let _ = handle.join();
                    }

                    // Create a new shutdown channel
                    let (new_tx, _) = oneshot::channel::<()>();
                    *shutdown_tx.lock().unwrap() = Some(new_tx);

                    // Start a new server
                    server_handle = start_server(Arc::clone(&shutdown_tx));
                    last_restart = Instant::now();
                }
            }
            Err(_) => {
                // No file changes, just continue
            }
        }
    }
}

fn start_server(
    shutdown_tx: Arc<Mutex<Option<oneshot::Sender<()>>>>,
) -> Option<thread::JoinHandle<()>> {
    println!("Starting server...");

    // Spawn a new thread for the server
    let handle = thread::spawn(move || {
        // Create a runtime for the Axum server
        let rt = tokio::runtime::Runtime::new().unwrap();

        rt.block_on(async {
            // Create the Axum server
            let service = ServeDir::new("content");
            let app = Router::new().fallback_service(service);

            // Get a new shutdown channel
            let (tx, rx) = oneshot::channel::<()>();
            *shutdown_tx.lock().unwrap() = Some(tx);

            // Bind to an address
            let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
            println!("Server started at http://{}", addr);

            // Start the server with graceful shutdown
            let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
            axum::serve(listener, app)
                .with_graceful_shutdown(async {
                    rx.await.ok();
                    println!("Server shutting down gracefully");
                })
                .await
                .unwrap();
        });
    });

    Some(handle)
}