autocommit 2026-01-12 17:45:25 CET

Author: mahkoh

generator/src/formatter.rs

@@ -1201,6 +1201,7 @@ fn format_wayland_debug(
     if !outgoing {
         prefix = "                ";
     }
+    wl!(r#"{prefix}#[cfg(feature = "logging")]"#)?;
     wl!(r#"{prefix}if self.core.state.log {{"#)?;
     wl!(r#"{prefix}    #[cold]"#)?;
     w!(r#"{prefix}    fn log(state: &State"#)?;

protocols/wlproxy/wlproxy-test.xml

@@ -40,6 +40,10 @@
     <event name="sent_object">
       <arg name="echo" type="new_id" interface="wlproxy_test_server_sent"/>
     </event>
+
+    <request name="create_non_forward">
+      <arg name="id" type="new_id" interface="wlproxy_test_non_forward"/>
+    </request>
   </interface>
 
   <interface name="wlproxy_test_array_echo" version="1">
@@ -74,4 +78,9 @@
 
     <event name="destroyed" type="destructor"/>
   </interface>
+
+  <interface name="wlproxy_test_non_forward" version="1">
+    <request name="echo"/>
+    <event name="echoed"/>
+  </interface>
 </protocol>

wl-proxy/Cargo.toml

@@ -25,6 +25,8 @@ parking_lot = "0.12.5"
 env_logger = "0.11.8"
 
 [features]
+default = ["logging"]
+logging = []
 
 # --generated start--
 all-protocols = [

wl-proxy/src/baseline/versions/prototyping.rs

@@ -148,6 +148,7 @@ const wlproxy_test_array_echo: u32 = 1;
 const wlproxy_test_dummy: u32 = 1;
 const wlproxy_test_fd_echo: u32 = 1;
 const wlproxy_test_hops: u32 = 1;
+const wlproxy_test_non_forward: u32 = 1;
 const wlproxy_test_object_echo: u32 = 1;
 const wlproxy_test_server_sent: u32 = 1;
 const wp_alpha_modifier_surface_v1: u32 = 1;
@@ -574,6 +575,8 @@ pub(in super::super) const BASELINE: &StaticCopyMap<ObjectInterface, u32> = {
         #[cfg(test)]
         { baseline[ObjectInterface::WlproxyTestHops.__linearize_d66aa8fa_6974_4651_b2b7_75291a9e7105()] = wlproxy_test_hops; }
         #[cfg(test)]
+        { baseline[ObjectInterface::WlproxyTestNonForward.__linearize_d66aa8fa_6974_4651_b2b7_75291a9e7105()] = wlproxy_test_non_forward; }
+        #[cfg(test)]
         { baseline[ObjectInterface::WlproxyTestObjectEcho.__linearize_d66aa8fa_6974_4651_b2b7_75291a9e7105()] = wlproxy_test_object_echo; }
         #[cfg(test)]
         { baseline[ObjectInterface::WlproxyTestServerSent.__linearize_d66aa8fa_6974_4651_b2b7_75291a9e7105()] = wlproxy_test_server_sent; }

wl-proxy/src/baseline/versions/prototyping.txt

@@ -143,6 +143,7 @@ wlproxy_test_array_echo = 1
 wlproxy_test_dummy = 1
 wlproxy_test_fd_echo = 1
 wlproxy_test_hops = 1
+wlproxy_test_non_forward = 1
 wlproxy_test_object_echo = 1
 wlproxy_test_server_sent = 1
 wp_alpha_modifier_surface_v1 = 1

wl-proxy/src/lib.rs

@@ -317,6 +317,51 @@
 //!
 //! This [wlproxy_sync_v1](https://github.com/mahkoh/wl-proxy/blob/master/protocols/wlproxy/wlproxy-sync-v1.xml)
 //! protocol can be used for this.
+//!
+//! # Logging
+//!
+//! Messages sent in all directions can be logged. The logged messages look like this:
+//!
+//! ```text
+//! [1679788.330] {socket-1} client#2    -> wl_display#1.get_registry(registry: wl_registry#2)
+//! ^~~~~~~~~~~~~
+//!  timestamp of the message
+//!               ^~~~~~~~~~
+//!                the logging prefix of the State
+//!                          ^~~~~~~~
+//!                           the sender or receiver
+//!                                      ^~
+//!                                       the direction of the message
+//!                                         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//!                                          the message
+//! ```
+//!
+//! By default, logging is controlled by the `WL_PROXY_DEBUG` environment variable. If it
+//! is set to 1, messages are logged, otherwise messages are not logged. Messages are
+//! always written to STDERR.
+//!
+//! Applications can disable or enable logging programmatically via
+//! [`StateBuilder::with_logging`](state::StateBuilder::with_logging).
+//!
+//! Messages can have a prefix that is taken from the `WL_PROXY_PREFIX` environment
+//! variable. Applications can augment this prefix via
+//! [`StateBuilder::with_log_prefix`](state::StateBuilder::with_log_prefix). This can be
+//! used to easily distinguish these log messages from WAYLAND_DEBUG messages. The
+//! [`SimpleProxy`](simple::SimpleProxy) always sets the prefix to a unique identifier
+//! of the connection to allow distinguishing messages from different clients.
+//!
+//! Each message indicates the sender or receiver of the message. For messages sent by/to
+//! clients, the client is identified as `client#N`. Note that `N` does not start at 1 nor
+//! are the number contiguous. For messages sent by/to the compositor, the identifier is
+//! `server`.
+//!
+//! The symbols `->` and `<=` indicate the direction of the message.
+//!
+//! Logging can be disabled at compile time by disabling the default-enabled `logging`
+//! feature. This can significantly improve compile times and reduce binary size. For
+//! example, the wl-veil application has a program size of 6.7 MB by default but only
+//! 4.4 MB with logging disabled at compile time. Most programs should leave logging
+//! enabled to aid debuggability.
 
 pub mod acceptor;
 pub mod client;

wl-proxy/src/object.rs

@@ -111,6 +111,12 @@ pub trait ObjectCoreApi {
     /// This ID is not reused for any other object for the lifetime of the [`State`].
     fn unique_id(&self) -> u64;
 
+    /// Returns the client ID of this object, if any.
+    fn client_id(&self) -> Option<u32>;
+
+    /// Returns the server ID of this object, if any.
+    fn server_id(&self) -> Option<u32>;
+
     /// Sends a wl_display.delete_id event for this object.
     ///
     /// This is similar to [`ObjectCoreApi::try_delete_id`] but logs a message instead of
@@ -162,6 +168,14 @@ impl ObjectCoreApi for ObjectCore {
         self.id
     }
 
+    fn client_id(&self) -> Option<u32> {
+        self.client_obj_id.get()
+    }
+
+    fn server_id(&self) -> Option<u32> {
+        self.server_obj_id.get()
+    }
+
     fn delete_id(&self) {
         if let Err(e) = self.try_delete_id() {
             log::warn!("Could not release a client id: {}", Report::new(e));
@@ -227,6 +241,14 @@ where
         self.core().unique_id()
     }
 
+    fn client_id(&self) -> Option<u32> {
+        self.core().client_id()
+    }
+
+    fn server_id(&self) -> Option<u32> {
+        self.core().server_id()
+    }
+
     fn delete_id(&self) {
         self.core().delete_id()
     }
@@ -445,9 +467,6 @@ impl ObjectCore {
         slf: Rc<dyn Object>,
     ) -> Result<(), IdError> {
         self.check_server_destroyed()?;
-        if let Some(id) = self.server_obj_id.get() {
-            return Err(IdError::HasServerId(id));
-        }
         let Some(server) = &self.state.server else {
             return Err(IdError::NoServer);
         };

wl-proxy/src/object/tests.rs

@@ -1,11 +1,12 @@
 use {
     crate::{
         baseline::Baseline,
-        object::{Object, ObjectRcUtils, ObjectUtils},
+        object::{Object, ObjectCoreApi, ObjectRcUtils, ObjectUtils},
         protocols::{
             wayland::wl_keyboard::WlKeyboard,
             wlproxy_test::{
                 wlproxy_test::{WlproxyTest, WlproxyTestHandler},
+                wlproxy_test_non_forward::{WlproxyTestNonForward, WlproxyTestNonForwardHandler},
                 wlproxy_test_server_sent::{WlproxyTestServerSent, WlproxyTestServerSentHandler},
             },
         },
@@ -77,3 +78,189 @@ fn duplicate_client_id() {
     tp.client_test.send_create_dummy(&dummy);
     tp.await_client_disconnected();
 }
+
+#[test]
+fn client_object_with_server_id() {
+    let tp = test_proxy();
+    tp.client_state
+        .server
+        .as_ref()
+        .unwrap()
+        .outgoing
+        .borrow_mut()
+        .formatter()
+        .words([1, 0, !0]);
+    tp.client_display.new_send_sync();
+    tp.await_client_disconnected();
+}
+
+#[test]
+fn duplicate_generated_client_id() {
+    let tp = test_proxy();
+    let ss = tp.proxy_test.new_send_sent_object();
+    assert!(tp.proxy_test.try_send_sent_object(&ss).is_err());
+}
+
+#[test]
+fn destroyed_client() {
+    let tp = test_proxy();
+    tp.proxy_client.disconnect();
+    assert!(tp.proxy_test.new_try_send_sent_object().is_err());
+}
+
+#[test]
+#[should_panic(expected = "NotServerId(50)")]
+fn invalid_server_id() {
+    let tp = test_proxy();
+    tp.proxy_client
+        .endpoint
+        .outgoing
+        .borrow_mut()
+        .formatter()
+        .words([
+            tp.proxy_test.client_id().unwrap(),
+            1,  // event sent_object
+            50, // id
+        ]);
+    tp.sync();
+}
+
+#[test]
+#[should_panic(expected = "ServerIdInUse(4294967295)")]
+fn duplicate_server_id() {
+    let tp = test_proxy();
+    for _ in 0..2 {
+        tp.proxy_client
+            .endpoint
+            .outgoing
+            .borrow_mut()
+            .formatter()
+            .words([
+                tp.proxy_test.client_id().unwrap(),
+                1,  // event sent_object
+                !0, // id
+            ]);
+    }
+    tp.sync();
+}
+
+#[test]
+fn server_destroyed() {
+    let tp = test_proxy();
+    tp.client_state.destroy();
+    assert!(tp.client_display.new_try_send_sync().is_err());
+}
+
+#[test]
+fn get_handler() {
+    struct H;
+    impl WlproxyTestHandler for H {}
+
+    let tp = test_proxy();
+    tp.client_test.set_handler(H);
+    tp.client_test.get_handler_mut::<H>();
+    tp.client_test.get_handler_ref::<H>();
+    assert!(tp.client_test.try_get_handler_mut::<H>().is_ok());
+    assert!(tp.client_test.try_get_handler_ref::<H>().is_ok());
+    let handler = tp.client_test.get_handler_ref::<H>();
+    assert!(tp.client_test.try_get_handler_ref::<H>().is_ok());
+    assert!(tp.client_test.try_get_handler_mut::<H>().is_err());
+    drop(handler);
+    let _handler = tp.client_test.get_handler_mut::<H>();
+    assert!(tp.client_test.try_get_handler_ref::<H>().is_err());
+    assert!(tp.client_test.try_get_handler_mut::<H>().is_err());
+}
+
+#[test]
+fn state() {
+    let tp = test_proxy();
+    assert!(Rc::ptr_eq(&tp.client_state, tp.client_test.state()));
+}
+
+#[test]
+fn client() {
+    let tp = test_proxy();
+    assert!(Rc::ptr_eq(
+        &tp.proxy_client,
+        tp.proxy_test.client().as_ref().unwrap()
+    ));
+}
+
+#[test]
+fn version() {
+    let tp = test_proxy();
+    assert_eq!(tp.client_test.version(), 1);
+}
+
+#[test]
+fn client_id() {
+    let tp = test_proxy();
+    assert_eq!(
+        tp.client_test.server_id().unwrap(),
+        tp.proxy_test.client_id().unwrap()
+    );
+}
+
+#[test]
+fn forward() {
+    struct Nfh(bool);
+    impl WlproxyTestNonForwardHandler for Nfh {
+        fn handle_echoed(&mut self, _slf: &Rc<WlproxyTestNonForward>) {
+            self.0 = true;
+        }
+    }
+
+    struct Th1;
+    impl WlproxyTestHandler for Th1 {
+        fn handle_create_non_forward(
+            &mut self,
+            _slf: &Rc<WlproxyTest>,
+            id: &Rc<WlproxyTestNonForward>,
+        ) {
+            id.set_forward_to_server(false);
+        }
+    }
+
+    struct Th2;
+    impl WlproxyTestHandler for Th2 {
+        fn handle_create_non_forward(
+            &mut self,
+            _slf: &Rc<WlproxyTest>,
+            id: &Rc<WlproxyTestNonForward>,
+        ) {
+            id.set_forward_to_client(false);
+        }
+    }
+
+    let tp = test_proxy();
+
+    let non_forward = tp.client_test.new_send_create_non_forward();
+    non_forward.set_handler(Nfh(false));
+    non_forward.send_echo();
+    tp.sync();
+    assert!(non_forward.get_handler_mut::<Nfh>().0);
+
+    tp.proxy_test.set_handler(Th1);
+
+    let non_forward = tp.client_test.new_send_create_non_forward();
+    non_forward.set_handler(Nfh(false));
+    non_forward.send_echo();
+    tp.sync();
+    assert!(!non_forward.get_handler_mut::<Nfh>().0);
+
+    tp.proxy_test.set_handler(Th2);
+
+    let non_forward = tp.client_test.new_send_create_non_forward();
+    non_forward.set_handler(Nfh(false));
+    non_forward.send_echo();
+    tp.sync();
+    assert!(!non_forward.get_handler_mut::<Nfh>().0);
+
+    tp.proxy_test.unset_handler();
+
+    let non_forward = tp.client_test.new_send_create_non_forward();
+    non_forward.set_handler(Nfh(false));
+    non_forward.send_echo();
+    tp.sync();
+    assert!(non_forward.get_handler_mut::<Nfh>().0);
+}