hyprwire 0.3.0

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
118
119

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

use hyprwire::server;
use std::io::Read;
use std::os::fd::AsRawFd;
use std::str::FromStr;
use std::{env, fs, 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 {
    manager: Option<my_manager_v1::MyManagerV1>,
    object: Option<my_object_v1::MyObjectV1>,
}

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!("Recvd message: {}", message)
            }
            my_manager_v1::Event::SendMessageArrayFd { message } => {
                println!("Received {} fds", message.len());

                for fd in message {
                    let mut file = fs::File::from(fd);
                    let mut buf = [0u8; 64];
                    let n = file.read(&mut buf).unwrap_or(0);
                    let data = String::from_utf8_lossy(&buf[..n]);
                    println!("fd {} with data: {}", file.as_raw_fd(), data);
                }
            }
            my_manager_v1::Event::SendMessageFd { message } => {
                let mut file = fs::File::from(message);
                let mut buf = [0u8; 64];
                let n = file.read(&mut buf).unwrap_or(0);
                let data = String::from_utf8_lossy(&buf[..n]);
                println!("Recvd fd {} with data: {}", file.as_raw_fd(), data);
            }
            my_manager_v1::Event::SendMessageArray { message } => {
                println!("Got array message: \"{}\"", message.join(", "));
            }
            my_manager_v1::Event::SendMessageArrayUint { message } => {
                let conct: Vec<String> = message.iter().map(|v| v.to_string()).collect();
                println!("Got uint array message: \"{}\"", conct.join(", "));
            }
            my_manager_v1::Event::MakeObject { seq } => {
                let obj = object
                    .make_object::<Self>(seq)
                    .expect("failed to create object");
                obj.send_send_message("Hello object");
                self.object = Some(obj);
            }
        }
    }
}

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<'_>,
    ) {
        match event {
            my_object_v1::Event::SendMessage { message } => {
                println!("Object says hello: {}", message);
            }
            my_object_v1::Event::SendEnum { message } => {
                println!("Object sent enum: {:?}", message);

                println!("Erroring out the client!");

                object.error(
                    test_protocol_v1::MyErrorEnum::ErrorImportant as u32,
                    "Important error occurred!",
                );
            }
            _ => {}
        }
    }
}

impl test_protocol_v1::TestProtocolV1Handler for App {
    fn bind(&mut self, object: my_manager_v1::MyManagerV1) {
        println!("{:?}", object.client().unwrap().creds().pid);
        object.client();
        println!("Object bound XD");
        object.send_send_message("Hello manager");
        self.manager = Some(object);
    }
}

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

    let path = socket_path();
    let mut sock = server::Server::bind(&path).unwrap();
    let mut app = App::default();
    sock.add_implementation::<test_protocol_v1::TestProtocolV1Impl, _>(1, &mut app);

    while sock.dispatch_events(&mut app, true).is_ok() {}
}