hyprwire 0.4.2

A fast and consistent wire protocol for IPC
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

mod test_protocol_v1 {
    hyprwire::include_protocol!("test_protocol_v1");
    pub use client::*;
    pub use spec::*;
}

use hyprwire::client;
use hyprwire_core::types::ProtocolSpec;
use std::io::Write;
use std::os::fd::AsRawFd;
use std::os::unix::net;
use std::str::FromStr;
use std::{env, path};
use test_protocol_v1::{my_manager_v1, my_object_v1};

fn socket_path() -> path::PathBuf {
    let mut runtime_dir = env::var("XDG_RUNTIME_DIR").unwrap();
    runtime_dir.push_str("/test-hw.sock");

    path::PathBuf::from_str(&runtime_dir).unwrap()
}

#[derive(Default)]
struct App {}

impl hyprwire::Dispatch<my_manager_v1::MyManagerV1> for App {
    fn event(
        &mut self,
        _object: &my_manager_v1::MyManagerV1,
        event: <my_manager_v1::MyManagerV1 as hyprwire::Object>::Event<'_>,
    ) {
        match event {
            my_manager_v1::Event::SendMessage { message } => {
                println!("Server says {}", message);
            }
            my_manager_v1::Event::RecvMessageArrayUint { message } => {
                println!("Server sent uint array {:?}", message);
            }
        }
    }
}

impl hyprwire::Dispatch<my_object_v1::MyObjectV1> for App {
    fn event(
        &mut self,
        _object: &my_object_v1::MyObjectV1,
        event: <my_object_v1::MyObjectV1 as hyprwire::Object>::Event<'_>,
    ) {
        let my_object_v1::Event::SendMessage { message } = event;
        println!("Server says on object {}", message);
    }
}

fn main() {
    env_logger::Builder::new()
        .filter(None, log::LevelFilter::Trace)
        .init();

    let path = socket_path();
    let mut socket = client::Client::connect(&path).unwrap();
    let event_queue = socket.new_event_queue();
    let mut state = App::default();

    socket.add_implementation::<test_protocol_v1::TestProtocolV1Impl>();
    event_queue.wait_for_handshake(&mut state).unwrap();

    let server_spec = socket
        .get_spec::<test_protocol_v1::TestProtocolV1Impl>()
        .unwrap();

    println!(
        "test protocol supported at version {}. Binding.",
        server_spec.spec_ver()
    );

    let manager = socket
        .bind::<my_manager_v1::MyManagerV1, _>(&event_queue, &mut state, server_spec.spec_ver())
        .unwrap();

    println!("Bound!");

    let mut pipes = net::UnixStream::pair().unwrap();
    let buf = b"pipe!";
    pipes.1.write_all(buf).unwrap();
    drop(pipes.1);

    println!("Will send fd {}", pipes.0.as_raw_fd());

    let mut pipes2 = net::UnixStream::pair().unwrap();
    let mut pipes3 = net::UnixStream::pair().unwrap();

    pipes2.1.write_all(b"o kurwa").unwrap();
    pipes3.1.write_all(b"bober!!").unwrap();
    drop(pipes2.1);
    drop(pipes3.1);

    manager.send_send_message("Hello!");
    manager.send_send_message_fd(&pipes.0);
    manager.send_send_message_array_fd(&[&pipes2.0, &pipes3.0]);
    manager.send_send_message_array(&["Hello", "via", "array!"]);
    manager.send_send_message_array::<&str>(&[]);
    manager.send_send_message_array_uint(&[69, 420, 1337]);

    event_queue.roundtrip(&mut state).unwrap();

    let obj = manager.send_make_object::<App>().unwrap();

    obj.send_send_message("Hello on object");
    obj.send_send_enum(test_protocol_v1::MyEnum::World);

    loop {
        if let Err(e) = event_queue.dispatch_events(&mut state, true) {
            log::error!("{e}");
            break;
        }
    }
}