wakezilla 0.1.41

A Wake-on-LAN proxy server written in Rust
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

use wakezilla::web::{self, Machine, PortForward, RequestRateConfig};

struct EnvGuard {
    key: &'static str,
}

impl EnvGuard {
    fn set(key: &'static str, value: &str) -> Self {
        std::env::set_var(key, value);
        Self { key }
    }
}

impl Drop for EnvGuard {
    fn drop(&mut self) {
        std::env::remove_var(self.key);
    }
}

#[test]
fn save_and_load_machines_round_trip() {
    let temp_dir = tempfile::tempdir().expect("failed to create temp directory");
    let db_path = temp_dir.path().join("machines.json");
    let _guard = EnvGuard::set(
        "WAKEZILLA_MACHINES_DB_PATH",
        db_path.to_str().expect("temp path should be valid utf-8"),
    );

    let machines = vec![Machine {
        mac: "AA:BB:CC:DD:EE:FF".into(),
        ip: "192.168.1.10".parse().unwrap(),
        name: "Desktop".into(),
        description: Some("Main desktop".into()),
        turn_off_port: Some(4000),
        can_be_turned_off: true,
        request_rate: RequestRateConfig {
            max_requests: 5,
            period_minutes: 15,
        },
        port_forwards: vec![PortForward {
            name: "SSH".into(),
            local_port: 2222,
            target_port: 22,
        }],
    }];

    web::save_machines(&machines).expect("failed to save machines");

    let loaded = web::load_machines().expect("failed to load machines");

    assert_eq!(loaded.len(), 1);
    let loaded_machine = &loaded[0];
    let original = &machines[0];

    assert_eq!(loaded_machine.mac, original.mac);
    assert_eq!(loaded_machine.ip, original.ip);
    assert_eq!(loaded_machine.name, original.name);
    assert_eq!(loaded_machine.description, original.description);
    assert_eq!(loaded_machine.turn_off_port, original.turn_off_port);
    assert_eq!(loaded_machine.can_be_turned_off, original.can_be_turned_off);
    assert_eq!(
        loaded_machine.request_rate.max_requests,
        original.request_rate.max_requests
    );
    assert_eq!(
        loaded_machine.request_rate.period_minutes,
        original.request_rate.period_minutes
    );
    assert_eq!(loaded_machine.port_forwards.len(), 1);
    let loaded_pf = &loaded_machine.port_forwards[0];
    let original_pf = &original.port_forwards[0];
    assert_eq!(loaded_pf.name, original_pf.name);
    assert_eq!(loaded_pf.local_port, original_pf.local_port);
    assert_eq!(loaded_pf.target_port, original_pf.target_port);
}