feat(server)!: convert display traits to ServerResult, drop anyhow dep

Final step of the staged migration started in #1242, continued in

Public API changes:

  RdpServerDisplay::updates
      -> Result<Box<dyn RdpServerDisplayUpdates>, anyhow::Error>
      => ServerResult<Box<dyn RdpServerDisplayUpdates>>

  RdpServerDisplayUpdates::next_update
      -> Result<Option<DisplayUpdate>, anyhow::Error>
      => ServerResult<Option<DisplayUpdate>>

These are breaking changes for handler implementations of the two
display traits.

Internal changes:

  - The from_anyhow private bridge and the AnyhowError wrapper struct
    in error.rs are removed.
  - The anyhow dependency is removed from ironrdp-server/Cargo.toml.
  - builder.rs's NoopDisplayUpdates / NoopDisplay impls and the
    docstring example in display.rs and README.md are updated to match
    the new trait shapes.
  - The example in crates/ironrdp/examples/server.rs and the integration
    test in crates/ironrdp-testsuite-extra/tests/main.rs are updated to
    return ServerResult from their RdpServerDisplay/Updates impls.
  - benches/src/perfenc.rs is updated to construct ServerError variants
    instead of anyhow::Error and converts at its own anyhow::Result main
    boundary via .map_err(|e| anyhow::anyhow!(e)).

After this commit, ironrdp-server has no anyhow dependency and the
public surface is fully typed against ServerError. Closes #1209.

Author: glamberson

Cargo.lock

@@ -60,13 +60,14 @@ async fn main() -> Result<(), anyhow::Error> {
     };
 
     let mut encoder = UpdateEncoder::new(DesktopSize { width, height }, flags, update_codecs, 8 * 1024 * 1024)
+        .map_err(|e| anyhow::anyhow!(e))
         .context("failed to initialize update encoder")?;
 
     let mut total_raw = 0u64;
     let mut total_enc = 0u64;
     let mut n_updates = 0u64;
     let mut updates = DisplayUpdates::new(file, DesktopSize { width, height }, fps);
-    while let Some(up) = updates.next_update().await? {
+    while let Some(up) = updates.next_update().await.map_err(|e| anyhow::anyhow!(e))? {
         if let DisplayUpdate::Bitmap(ref up) = up {
             total_raw += u64::try_from(up.data.len())?;
         } else {
@@ -78,7 +79,7 @@ async fn main() -> Result<(), anyhow::Error> {
             let Some(frag) = iter.next().await else {
                 break;
             };
-            let len = u64::try_from(frag?.data.len())?;
+            let len = u64::try_from(frag.map_err(|e| anyhow::anyhow!(e))?.data.len())?;
             total_enc += len;
         }
         n_updates += 1;
@@ -121,12 +122,17 @@ impl DisplayUpdates {
 
 #[async_trait::async_trait]
 impl RdpServerDisplayUpdates for DisplayUpdates {
-    async fn next_update(&mut self) -> anyhow::Result<Option<DisplayUpdate>> {
+    async fn next_update(&mut self) -> ironrdp::server::ServerResult<Option<DisplayUpdate>> {
+        use ironrdp::server::ServerErrorExt as _;
+
         let stride = self.desktop_size.width as usize * 4;
         let frame_size = stride * self.desktop_size.height as usize;
         let mut buf = vec![0u8; frame_size];
         // FIXME: AsyncReadExt::read_exact is not cancellation safe.
-        self.file.read_exact(&mut buf).await.context("read exact")?;
+        self.file
+            .read_exact(&mut buf)
+            .await
+            .map_err(|e| ironrdp::server::ServerError::io("read exact", e))?;
 
         let now = Instant::now();
         if let Some(last_update_time) = self.last_update_time {
@@ -135,7 +141,7 @@ impl RdpServerDisplayUpdates for DisplayUpdates {
                 sleep(Duration::from_millis(
                     1000 / self.fps
                         - u64::try_from(elapsed.as_millis())
-                            .context("invalid `elapsed millis`: out of range integral conversion")?,
+                            .map_err(|e| ironrdp::server::ServerError::custom("invalid `elapsed millis`", e))?,
                 ))
                 .await;
             }
@@ -145,11 +151,14 @@ impl RdpServerDisplayUpdates for DisplayUpdates {
         let up = DisplayUpdate::Bitmap(BitmapUpdate {
             x: 0,
             y: 0,
-            width: NonZeroU16::new(self.desktop_size.width).context("width cannot be zero")?,
-            height: NonZeroU16::new(self.desktop_size.height).context("height cannot be zero")?,
+            width: NonZeroU16::new(self.desktop_size.width)
+                .ok_or_else(|| ironrdp::server::ServerError::reason("perfenc", "width cannot be zero"))?,
+            height: NonZeroU16::new(self.desktop_size.height)
+                .ok_or_else(|| ironrdp::server::ServerError::reason("perfenc", "height cannot be zero"))?,
             format: PixelFormat::RgbX32,
             data: buf.into(),
-            stride: NonZeroUsize::new(stride).context("stride cannot be zero")?,
+            stride: NonZeroUsize::new(stride)
+                .ok_or_else(|| ironrdp::server::ServerError::reason("perfenc", "stride cannot be zero"))?,
         });
         Ok(Some(up))
     }

benches/src/perfenc.rs

@@ -33,7 +33,6 @@ nscodec = ["dep:ironrdp-nscodec"]
 __bench = ["dep:visibility"]
 
 [dependencies]
-anyhow = "1.0"
 tokio = { version = "1", features = ["net", "macros", "sync", "rt"] } # public
 tokio-rustls = "0.26" # public
 async-trait = "0.1"

crates/ironrdp-server/Cargo.toml

@@ -31,9 +31,9 @@ This crate is part of the [IronRDP] project.
 Enable the `echo` feature to use the ECHO dynamic virtual channel (`MS-RDPEECO`) and measure round-trip time.
 
 ```rust
-use ironrdp_server::RdpServer;
+use ironrdp_server::{RdpServer, ServerError, ServerErrorExt as _, ServerResult};
 
-# async fn demo(mut server: RdpServer) -> anyhow::Result<()> {
+# async fn demo(mut server: RdpServer) -> ServerResult<()> {
 // Grab and clone the shared handle before moving the server into a task.
 let echo = server.echo_handle().clone();
 
@@ -54,8 +54,10 @@ local
 			}
 		}
 
-		server_task.await??;
-		Ok::<(), anyhow::Error>(())
+		server_task
+			.await
+			.map_err(|e| ServerError::custom("server task", e))??;
+		Ok::<(), ServerError>(())
 	})
 	.await?;
 # Ok(()) }

crates/ironrdp-server/README.md

@@ -2,7 +2,6 @@ use core::net::SocketAddr;
 use core::sync::atomic::{AtomicBool, AtomicU32};
 use std::sync::Arc;
 
-use anyhow::Result;
 use ironrdp_pdu::rdp::capability_sets::{BitmapCodecs, server_codecs_capabilities};
 use tokio_rustls::TlsAcceptor;
 
@@ -12,6 +11,7 @@ use super::display::{DesktopSize, RdpServerDisplay};
 use super::gfx::GfxServerFactory;
 use super::handler::{KeyboardEvent, MouseEvent, RdpServerInputHandler};
 use super::server::{ConnectionHandler, CredentialValidator, RdpServer, RdpServerOptions, RdpServerSecurity};
+use crate::error::ServerResult;
 use crate::{DisplayUpdate, RdpServerDisplayUpdates, SoundServerFactory};
 
 pub struct WantsAddr {}
@@ -289,7 +289,7 @@ struct NoopDisplayUpdates;
 
 #[async_trait::async_trait]
 impl RdpServerDisplayUpdates for NoopDisplayUpdates {
-    async fn next_update(&mut self) -> Result<Option<DisplayUpdate>> {
+    async fn next_update(&mut self) -> ServerResult<Option<DisplayUpdate>> {
         let () = core::future::pending().await;
         unreachable!()
     }
@@ -303,7 +303,7 @@ impl RdpServerDisplay for NoopDisplay {
         DesktopSize { width: 0, height: 0 }
     }
 
-    async fn updates(&mut self) -> Result<Box<dyn RdpServerDisplayUpdates>> {
+    async fn updates(&mut self) -> ServerResult<Box<dyn RdpServerDisplayUpdates>> {
         Ok(Box::new(NoopDisplayUpdates {}))
     }
 }

crates/ironrdp-server/src/builder.rs

@@ -1,12 +1,13 @@
 use core::num::{NonZeroU16, NonZeroUsize};
 
-use anyhow::Result;
 use bytes::{Bytes, BytesMut};
 use ironrdp_displaycontrol::pdu::DisplayControlMonitorLayout;
 use ironrdp_graphics::diff;
 use ironrdp_pdu::pointer::PointerPositionAttribute;
 use tracing::{debug, warn};
 
+use crate::error::ServerResult;
+
 #[rustfmt::skip]
 pub use ironrdp_acceptor::DesktopSize;
 pub use ironrdp_graphics::image_processing::PixelFormat;
@@ -246,24 +247,23 @@ pub trait RdpServerDisplayUpdates {
     /// This method MUST be cancellation safe because it is used in a
     /// `tokio::select!` statement. If some other branch completes first, it
     /// MUST be guaranteed that no data is lost.
-    async fn next_update(&mut self) -> Result<Option<DisplayUpdate>>;
+    async fn next_update(&mut self) -> ServerResult<Option<DisplayUpdate>>;
 }
 
 /// Display for an RDP server
 ///
 /// # Example
 ///
 /// ```
-///# use anyhow::Result;
-/// use ironrdp_server::{DesktopSize, DisplayUpdate, RdpServerDisplay, RdpServerDisplayUpdates};
+/// use ironrdp_server::{DesktopSize, DisplayUpdate, RdpServerDisplay, RdpServerDisplayUpdates, ServerResult};
 ///
 /// pub struct DisplayUpdates {
 ///     receiver: tokio::sync::mpsc::Receiver<DisplayUpdate>,
 /// }
 ///
 /// #[async_trait::async_trait]
 /// impl RdpServerDisplayUpdates for DisplayUpdates {
-///     async fn next_update(&mut self) -> anyhow::Result<Option<DisplayUpdate>> {
+///     async fn next_update(&mut self) -> ServerResult<Option<DisplayUpdate>> {
 ///         Ok(self.receiver.recv().await)
 ///     }
 /// }
@@ -279,7 +279,7 @@ pub trait RdpServerDisplayUpdates {
 ///         DesktopSize { width: self.width, height: self.height }
 ///     }
 ///
-///     async fn updates(&mut self) -> Result<Box<dyn RdpServerDisplayUpdates>> {
+///     async fn updates(&mut self) -> ServerResult<Box<dyn RdpServerDisplayUpdates>> {
 ///         Ok(Box::new(DisplayUpdates { receiver: todo!() }))
 ///     }
 /// }
@@ -298,7 +298,7 @@ pub trait RdpServerDisplay: Send {
     }
 
     /// Return a display updates receiver
-    async fn updates(&mut self) -> Result<Box<dyn RdpServerDisplayUpdates>>;
+    async fn updates(&mut self) -> ServerResult<Box<dyn RdpServerDisplayUpdates>>;
 
     /// Request a new size for the display
     fn request_layout(&mut self, layout: DisplayControlMonitorLayout) {

crates/ironrdp-server/src/display.rs

@@ -174,36 +174,3 @@ impl<T> ServerResultExt for ServerResult<T> {
         self.map_err(|e| e.with_source(source))
     }
 }
-
-/// Bridges anyhow errors at the public API boundary while the migration to
-/// typed errors is staged.
-///
-/// Internal call sites still use `anyhow::Result`; conversion happens here so
-/// the public signatures can advertise [`ServerResult`] today without forcing
-/// every internal site to convert in this PR. PR #2 in the staged migration
-/// (see [#1209]) removes the remaining `anyhow` usage and this helper.
-///
-/// [#1209]: https://github.com/Devolutions/IronRDP/issues/1209
-pub(crate) fn from_anyhow(error: anyhow::Error) -> ServerError {
-    ServerError::new("server error", ServerErrorKind::Custom).with_source(AnyhowError(error))
-}
-
-/// Newtype wrapper that gives [`anyhow::Error`] a `core::error::Error` impl
-/// suitable for `ironrdp_error::Error::with_source`.
-#[derive(Debug)]
-struct AnyhowError(anyhow::Error);
-
-impl fmt::Display for AnyhowError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:#}", self.0)
-    }
-}
-
-impl core::error::Error for AnyhowError {
-    /// Forwards to the wrapped [`anyhow::Error`]'s cause chain so callers
-    /// traversing [`core::error::Error::source`] reach the original root
-    /// cause rather than stopping at this newtype.
-    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
-        self.0.source()
-    }
-}

crates/ironrdp-server/src/error.rs

@@ -38,7 +38,7 @@ use crate::clipboard::CliprdrServerFactory;
 use crate::display::{DisplayUpdate, RdpServerDisplay};
 use crate::echo::{EchoDvcBridge, EchoServerHandle, EchoServerMessage, build_echo_request};
 use crate::encoder::{UpdateEncoder, UpdateEncoderCodecs};
-use crate::error::{ServerError, ServerErrorExt as _, ServerResult, ServerResultExt as _, from_anyhow};
+use crate::error::{ServerError, ServerErrorExt as _, ServerResult, ServerResultExt as _};
 #[cfg(feature = "egfx")]
 use crate::gfx::{EgfxServerMessage, GfxServerFactory};
 use crate::handler::RdpServerInputHandler;
@@ -361,8 +361,7 @@ impl DisplayControlHandler for DisplayControlBackend {
 /// ```
 /// use ironrdp_server::{RdpServer, RdpServerInputHandler, RdpServerDisplay, RdpServerDisplayUpdates};
 ///
-///# use anyhow::Result;
-///# use ironrdp_server::{DisplayUpdate, DesktopSize, KeyboardEvent, MouseEvent};
+///# use ironrdp_server::{DisplayUpdate, DesktopSize, KeyboardEvent, MouseEvent, ServerResult};
 ///# use tokio_rustls::TlsAcceptor;
 ///# struct NoopInputHandler;
 ///# impl RdpServerInputHandler for NoopInputHandler {
@@ -375,11 +374,11 @@ impl DisplayControlHandler for DisplayControlBackend {
 ///#     async fn size(&mut self) -> DesktopSize {
 ///#         todo!()
 ///#     }
-///#     async fn updates(&mut self) -> Result<Box<dyn RdpServerDisplayUpdates>> {
+///#     async fn updates(&mut self) -> ServerResult<Box<dyn RdpServerDisplayUpdates>> {
 ///#         todo!()
 ///#     }
 ///# }
-///# async fn stub() -> Result<()> {
+///# async fn stub() -> ServerResult<()> {
 /// fn make_tls_acceptor() -> TlsAcceptor {
 ///    /* snip */
 ///#    todo!()
@@ -1127,7 +1126,7 @@ impl RdpServer {
         W: FramedWrite,
     {
         debug!("Starting client loop");
-        let mut display_updates = self.display.lock().await.updates().await.map_err(from_anyhow)?;
+        let mut display_updates = self.display.lock().await.updates().await?;
         let mut writer = SharedWriter::new(writer);
         let mut display_writer = writer.clone();
         let mut event_writer = writer.clone();

crates/ironrdp-server/src/server.rs

@@ -5,15 +5,14 @@ use std::path::Path;
 use std::sync::Arc;
 use std::time::Instant;
 
-use anyhow::Result;
 use ironrdp::connector;
 use ironrdp::dvc::DrdynvcClient;
 use ironrdp::echo::client::EchoClient;
 use ironrdp::pdu::rdp::capability_sets::MajorPlatformType;
 use ironrdp::pdu::{self, gcc};
 use ironrdp::server::{
     self, DesktopSize, DisplayUpdate, KeyboardEvent, MouseEvent, PixelFormat, RdpServer, RdpServerDisplay,
-    RdpServerDisplayUpdates, RdpServerInputHandler, ServerEvent, TlsIdentityCtx,
+    RdpServerDisplayUpdates, RdpServerInputHandler, ServerEvent, ServerResult, TlsIdentityCtx,
 };
 use ironrdp::session::image::DecodedImage;
 use ironrdp::session::{self, ActiveStage, ActiveStageOutput};
@@ -183,7 +182,7 @@ struct TestDisplayUpdates {
 
 #[async_trait::async_trait]
 impl RdpServerDisplayUpdates for TestDisplayUpdates {
-    async fn next_update(&mut self) -> Result<Option<DisplayUpdate>> {
+    async fn next_update(&mut self) -> ServerResult<Option<DisplayUpdate>> {
         let mut rx = self.rx.lock().await;
 
         Ok(rx.recv().await)
@@ -203,7 +202,7 @@ impl RdpServerDisplay for TestDisplay {
         }
     }
 
-    async fn updates(&mut self) -> Result<Box<dyn RdpServerDisplayUpdates>> {
+    async fn updates(&mut self) -> ServerResult<Box<dyn RdpServerDisplayUpdates>> {
         Ok(Box::new(TestDisplayUpdates {
             rx: Arc::clone(&self.rx),
         }))

crates/ironrdp-testsuite-extra/tests/e2e.rs

@@ -153,7 +153,7 @@ struct DisplayUpdates;
 
 #[async_trait::async_trait]
 impl RdpServerDisplayUpdates for DisplayUpdates {
-    async fn next_update(&mut self) -> anyhow::Result<Option<DisplayUpdate>> {
+    async fn next_update(&mut self) -> ironrdp::server::ServerResult<Option<DisplayUpdate>> {
         sleep(Duration::from_millis(100)).await;
         let mut rng = rand::rng();
 
@@ -205,7 +205,7 @@ impl RdpServerDisplay for Handler {
         }
     }
 
-    async fn updates(&mut self) -> anyhow::Result<Box<dyn RdpServerDisplayUpdates>> {
+    async fn updates(&mut self) -> ironrdp::server::ServerResult<Box<dyn RdpServerDisplayUpdates>> {
         Ok(Box::new(DisplayUpdates {}))
     }
 }