`1fd4b17`

add portal request dispatcher

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 months ago

SHA: 1fd4b176164fa70604ca00a916122a281279a2f7
Parents: cbfcc1e
Tree: f1485f5

3 changed files

Status	File	+	-
M	`garwarp/src/dbus.rs`	140	32
M	`garwarp/src/main.rs`	1	0
A	`garwarp/src/portal_dispatch.rs`	191	0

garwarp/src/dbus.rsmodified

 -use std::collections::HashMap;
 +use std::{
 +    collections::HashMap,
 +    sync::{Arc, Mutex},
 +};
  use zbus::{
      blocking::Connection,
      zvariant::{OwnedObjectPath, OwnedValue},
  };
 +use crate::config::Config;
  use crate::error::{PortalError, map_portal_error};
  use crate::portal::derive_request_id_from_handle;
 +use crate::portal_dispatch::PortalDispatch;
  use crate::portal_options::{
      parse_app_chooser_options, parse_file_chooser_options, parse_screenshot_options,
  };
      (mapping.code as u32, HashMap::new())
+ }
 -fn request_id_for_call(
 +fn request_identity_for_call(
      request_handle: &OwnedObjectPath,
 -    header: Header<'_>,
 -) -> Result<String, PortalError> {
 +    header: &Header<'_>,
 +) -> Result<(String, String), PortalError> {
      let sender = header
          .sender()
 -        .map(|sender| sender.as_str())
 +        .map(|sender| sender.as_str().to_string())
          .ok_or(PortalError::UnauthorizedClient)?;
 +    let request_id = derive_request_id_from_handle(&sender, request_handle.as_str())?;
 +    Ok((sender, request_id))
 +}
 -    derive_request_id_from_handle(sender, request_handle.as_str())
 +fn with_dispatch<T>(
 +    dispatch: &Arc<Mutex<PortalDispatch>>,
 +    callback: impl FnOnce(&mut PortalDispatch) -> Result<T, PortalError>,
 +) -> Result<T, PortalError> {
 +    let mut dispatch = dispatch.lock().map_err(|_| PortalError::InternalFailure)?;
 +    callback(&mut dispatch)
+ }
  pub struct SessionNameGuard {
  impl SessionNameGuard {
      pub fn acquire() -> zbus::Result<Self> {
 +        let dispatch = Arc::new(Mutex::new(PortalDispatch::new(
 +            Config::from_env().request_timeout,
 +        )));
          let connection = Connection::session()?;
          connection.request_name(BACKEND_DBUS_NAME)?;
+         {
              let object_server = connection.object_server();
 -            object_server.at(BACKEND_OBJECT_PATH, ScreenshotPortal)?;
 -            object_server.at(BACKEND_OBJECT_PATH, FileChooserPortal)?;
 -            object_server.at(BACKEND_OBJECT_PATH, AppChooserPortal)?;
 +            object_server.at(
 +                BACKEND_OBJECT_PATH,
 +                ScreenshotPortal::new(Arc::clone(&dispatch)),
 +            )?;
 +            object_server.at(
 +                BACKEND_OBJECT_PATH,
 +                FileChooserPortal::new(Arc::clone(&dispatch)),
 +            )?;
 +            object_server.at(BACKEND_OBJECT_PATH, AppChooserPortal::new(dispatch))?;
+         }
          Ok(Self {
              _connection: connection,
+ }
  #[derive(Debug)]
 -struct ScreenshotPortal;
 +struct ScreenshotPortal {
 +    dispatch: Arc<Mutex<PortalDispatch>>,
 +}
++
 +impl ScreenshotPortal {
 +    fn new(dispatch: Arc<Mutex<PortalDispatch>>) -> Self {
 +        Self { dispatch }
 +    }
 +}
  #[interface(name = "org.freedesktop.impl.portal.Screenshot")]
  impl ScreenshotPortal {
          if let Err(error) = parse_screenshot_options(&_options) {
              return failure_response(&error);
+         }
 -        if let Err(error) = request_id_for_call(&handle, header) {
 +        let (sender, request_id) = match request_identity_for_call(&handle, &header) {
 +            Ok(identity) => identity,
 +            Err(error) => return failure_response(&error),
 +        };
 +        if let Err(error) = with_dispatch(&self.dispatch, |dispatch| {
 +            dispatch.register_unimplemented_call(&request_id, &sender, _app_id, _parent_window)
 +        }) {
              return failure_response(&error);
+         }
          failed_response()
          if let Err(error) = parse_screenshot_options(&_options) {
              return failure_response(&error);
+         }
 -        if let Err(error) = request_id_for_call(&handle, header) {
 +        let (sender, request_id) = match request_identity_for_call(&handle, &header) {
 +            Ok(identity) => identity,
 +            Err(error) => return failure_response(&error),
 +        };
 +        if let Err(error) = with_dispatch(&self.dispatch, |dispatch| {
 +            dispatch.register_unimplemented_call(&request_id, &sender, _app_id, _parent_window)
 +        }) {
              return failure_response(&error);
+         }
          failed_response()
+ }
  #[derive(Debug)]
 -struct FileChooserPortal;
 +struct FileChooserPortal {
 +    dispatch: Arc<Mutex<PortalDispatch>>,
 +}
++
 +impl FileChooserPortal {
 +    fn new(dispatch: Arc<Mutex<PortalDispatch>>) -> Self {
 +        Self { dispatch }
 +    }
 +}
  #[interface(name = "org.freedesktop.impl.portal.FileChooser")]
  impl FileChooserPortal {
          if let Err(error) = parse_file_chooser_options(&_options) {
              return failure_response(&error);
+         }
 -        if let Err(error) = request_id_for_call(&handle, header) {
 +        let (sender, request_id) = match request_identity_for_call(&handle, &header) {
 +            Ok(identity) => identity,
 +            Err(error) => return failure_response(&error),
 +        };
 +        if let Err(error) = with_dispatch(&self.dispatch, |dispatch| {
 +            dispatch.register_unimplemented_call(&request_id, &sender, _app_id, _parent_window)
 +        }) {
              return failure_response(&error);
+         }
          failed_response()
          if let Err(error) = parse_file_chooser_options(&_options) {
              return failure_response(&error);
+         }
 -        if let Err(error) = request_id_for_call(&handle, header) {
 +        let (sender, request_id) = match request_identity_for_call(&handle, &header) {
 +            Ok(identity) => identity,
 +            Err(error) => return failure_response(&error),
 +        };
 +        if let Err(error) = with_dispatch(&self.dispatch, |dispatch| {
 +            dispatch.register_unimplemented_call(&request_id, &sender, _app_id, _parent_window)
 +        }) {
              return failure_response(&error);
+         }
          failed_response()
          if let Err(error) = parse_file_chooser_options(&_options) {
              return failure_response(&error);
+         }
 -        if let Err(error) = request_id_for_call(&handle, header) {
 +        let (sender, request_id) = match request_identity_for_call(&handle, &header) {
 +            Ok(identity) => identity,
 +            Err(error) => return failure_response(&error),
 +        };
 +        if let Err(error) = with_dispatch(&self.dispatch, |dispatch| {
 +            dispatch.register_unimplemented_call(&request_id, &sender, _app_id, _parent_window)
 +        }) {
              return failure_response(&error);
+         }
          failed_response()
+ }
  #[derive(Debug)]
 -struct AppChooserPortal;
 +struct AppChooserPortal {
 +    dispatch: Arc<Mutex<PortalDispatch>>,
 +}
++
 +impl AppChooserPortal {
 +    fn new(dispatch: Arc<Mutex<PortalDispatch>>) -> Self {
 +        Self { dispatch }
 +    }
 +}
  #[interface(name = "org.freedesktop.impl.portal.AppChooser")]
  impl AppChooserPortal {
          if let Err(error) = parse_app_chooser_options(&_options) {
              return failure_response(&error);
+         }
 -        if let Err(error) = request_id_for_call(&handle, header) {
 +        let (sender, request_id) = match request_identity_for_call(&handle, &header) {
 +            Ok(identity) => identity,
 +            Err(error) => return failure_response(&error),
 +        };
 +        if let Err(error) = with_dispatch(&self.dispatch, |dispatch| {
 +            dispatch.register_unimplemented_call(&request_id, &sender, _app_id, _parent_window)
 +        }) {
              return failure_response(&error);
+         }
          failed_response()
          _choices: Vec<String>,
          #[zbus(header)] header: Header<'_>,
      ) -> zbus::fdo::Result<()> {
 -        request_id_for_call(&handle, header)
 -            .map(|_| ())
 -            .map_err(|error| zbus::fdo::Error::Failed(map_portal_error(&error).reason.to_string()))
 +        let (sender, request_id) =
 +            request_identity_for_call(&handle, &header).map_err(|error| {
 +                zbus::fdo::Error::Failed(map_portal_error(&error).reason.to_string())
 +            })?;
 +        with_dispatch(&self.dispatch, |dispatch| {
 +            dispatch.validate_update_choices(&request_id, &sender)
 +        })
 +        .map_err(|error| zbus::fdo::Error::Failed(map_portal_error(&error).reason.to_string()))
+     }
      #[zbus(property)]
  #[cfg(test)]
  mod tests {
 -    use std::collections::HashMap;
 +    use std::{
 +        collections::HashMap,
 +        sync::{Arc, Mutex},
 +        time::Duration,
 +    };
      use super::{
          AppChooserPortal, BACKEND_OBJECT_PATH, FileChooserPortal, INTERFACE_VERSION,
          ScreenshotPortal,
      };
      use crate::error::PortalResponseCode;
 +    use crate::portal_dispatch::PortalDispatch;
      use zbus::{
          message::{Header, Message},
          zvariant::{OwnedObjectPath, OwnedValue},
      #[test]
      fn portal_interfaces_report_expected_version() {
 -        assert_eq!(ScreenshotPortal.version(), INTERFACE_VERSION);
 -        assert_eq!(FileChooserPortal.version(), INTERFACE_VERSION);
 -        assert_eq!(AppChooserPortal.version(), INTERFACE_VERSION);
 +        assert_eq!(
 +            ScreenshotPortal::new(test_dispatch()).version(),
 +            INTERFACE_VERSION
 +        );
 +        assert_eq!(
 +            FileChooserPortal::new(test_dispatch()).version(),
 +            INTERFACE_VERSION
 +        );
 +        assert_eq!(
 +            AppChooserPortal::new(test_dispatch()).version(),
 +            INTERFACE_VERSION
 +        );
+     }
      #[test]
      fn screenshot_and_pick_color_return_failed_placeholder() {
 +        let portal = ScreenshotPortal::new(test_dispatch());
          let options = HashMap::<String, OwnedValue>::new();
 -        let (response, results) = ScreenshotPortal.screenshot(
 +        let (response, results) = portal.screenshot(
              request_handle_path(),
              "org.test.App",
              "x11:0x2a",
          assert_eq!(response, PortalResponseCode::Failed as u32);
          assert!(results.is_empty());
 -        let (response, results) = ScreenshotPortal.pick_color(
 +        let (response, results) = portal.pick_color(
              request_handle_path(),
              "org.test.App",
              "",
      #[test]
      fn file_chooser_methods_return_failed_placeholder() {
 +        let portal = FileChooserPortal::new(test_dispatch());
          let options = HashMap::<String, OwnedValue>::new();
 -        let (response, results) = FileChooserPortal.open_file(
 +        let (response, results) = portal.open_file(
              request_handle_path(),
              "org.test.App",
              "",
          assert_eq!(response, PortalResponseCode::Failed as u32);
          assert!(results.is_empty());
 -        let (response, results) = FileChooserPortal.save_file(
 +        let (response, results) = portal.save_file(
              request_handle_path(),
              "org.test.App",
              "",
          assert_eq!(response, PortalResponseCode::Failed as u32);
          assert!(results.is_empty());
 -        let (response, results) = FileChooserPortal.save_files(
 +        let (response, results) = portal.save_files(
              request_handle_path(),
              "org.test.App",
              "",
      #[test]
      fn app_chooser_methods_have_stable_placeholders() {
 +        let portal = AppChooserPortal::new(test_dispatch());
          let options = HashMap::<String, OwnedValue>::new();
          let choices = vec!["org.test.Viewer".to_string()];
 -        let (response, results) = AppChooserPortal.choose_application(
 +        let (response, results) = portal.choose_application(
              request_handle_path(),
              "org.test.App",
              "",
          assert_eq!(response, PortalResponseCode::Failed as u32);
          assert!(results.is_empty());
 -        let error = AppChooserPortal
 +        let error = portal
              .update_choices(request_handle_path(), choices, test_call_header())
              .expect_err("update choices should reject missing sender metadata");
          match error {
              .expect("test message");
          Box::leak(Box::new(call)).header()
+     }
++
 +    fn test_dispatch() -> Arc<Mutex<PortalDispatch>> {
 +        Arc::new(Mutex::new(PortalDispatch::new(Duration::from_secs(30))))
 +    }
+ }

garwarp/src/main.rsmodified

  mod lock;
  mod logging;
  mod portal;
 +mod portal_dispatch;
  mod portal_options;
  mod request;
  mod request_store;

garwarp/src/portal_dispatch.rsadded

 +#![allow(dead_code)]
++
 +use std::time::Duration;
++
 +use crate::error::PortalError;
 +use crate::request::{RequestError, RequestOwner, RequestRecord, RequestRegistry, RequestState};
 +use crate::validate::validate_request_identity;
 +use crate::window::parse_optional_parent_window;
++
 +#[derive(Debug)]
 +pub struct PortalDispatch {
 +    requests: RequestRegistry,
 +}
++
 +impl PortalDispatch {
 +    #[must_use]
 +    pub fn new(request_timeout: Duration) -> Self {
 +        Self {
 +            requests: RequestRegistry::new(request_timeout),
 +        }
 +    }
++
 +    pub fn register_unimplemented_call(
 +        &mut self,
 +        request_id: &str,
 +        sender: &str,
 +        app_id: &str,
 +        parent_window: &str,
 +    ) -> Result<(), PortalError> {
 +        let app_id = normalize_optional(app_id);
 +        validate_request_identity(request_id, sender, app_id)?;
++
 +        let parent_window = parse_optional_parent_window(normalize_optional(parent_window))
 +            .map_err(|_| PortalError::InvalidParentWindow)?;
 +        let owner = RequestOwner::new(sender.to_string(), app_id.map(str::to_string));
 +        let state = self.begin_request(request_id, owner.clone(), parent_window)?;
++
 +        if !state.is_terminal() {
 +            self.requests
 +                .transition(request_id, &owner, RequestState::Failed)
 +                .map_err(|error| map_request_error_to_portal(&error))?;
 +        }
++
 +        Ok(())
 +    }
++
 +    pub fn validate_update_choices(
 +        &self,
 +        request_id: &str,
 +        sender: &str,
 +    ) -> Result<(), PortalError> {
 +        validate_request_identity(request_id, sender, None)?;
++
 +        let record = self
 +            .requests
 +            .record(request_id)
 +            .ok_or(PortalError::RequestNotFound)?;
 +        if record.owner.sender != sender {
 +            return Err(PortalError::OwnershipMismatch);
 +        }
 +        if record.state.is_terminal() {
 +            return Err(PortalError::InvalidTransition);
 +        }
 +        Ok(())
 +    }
++
 +    #[must_use]
 +    pub fn record(&self, request_id: &str) -> Option<RequestRecord> {
 +        self.requests.record(request_id)
 +    }
++
 +    fn begin_request(
 +        &mut self,
 +        request_id: &str,
 +        owner: RequestOwner,
 +        parent_window: Option<crate::window::ParentWindowContext>,
 +    ) -> Result<RequestState, PortalError> {
 +        match self
 +            .requests
 +            .begin(request_id.to_string(), owner.clone(), parent_window)
 +        {
 +            Ok(()) => Ok(RequestState::Pending),
 +            Err(RequestError::AlreadyExists(_)) => match self.requests.record(request_id) {
 +                Some(record) if record.owner == owner && record.parent_window == parent_window => {
 +                    Ok(record.state)
 +                }
 +                Some(record) if record.owner != owner => Err(PortalError::OwnershipMismatch),
 +                _ => Err(PortalError::RequestAlreadyExists),
 +            },
 +            Err(error) => Err(map_request_error_to_portal(&error)),
 +        }
 +    }
 +}
++
 +fn normalize_optional(input: &str) -> Option<&str> {
 +    let trimmed = input.trim();
 +    (!trimmed.is_empty()).then_some(trimmed)
 +}
++
 +fn map_request_error_to_portal(error: &RequestError) -> PortalError {
 +    match error {
 +        RequestError::AlreadyExists(_) => PortalError::RequestAlreadyExists,
 +        RequestError::NotFound(_) => PortalError::RequestNotFound,
 +        RequestError::OwnerMismatch(_) => PortalError::OwnershipMismatch,
 +        RequestError::InvalidTransition { .. } => PortalError::InvalidTransition,
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use std::time::Duration;
++
 +    use super::PortalDispatch;
 +    use crate::error::PortalError;
 +    use crate::request::RequestState;
 +    use crate::window::ParentWindowContext;
++
 +    #[test]
 +    fn register_unimplemented_call_transitions_request_to_failed() {
 +        let mut dispatch = new_dispatch();
 +        dispatch
 +            .register_unimplemented_call("req:1_42:token_1", ":1.42", "org.test.App", "x11:0x2a")
 +            .expect("register request");
++
 +        let record = dispatch
 +            .record("req:1_42:token_1")
 +            .expect("record should exist");
 +        assert_eq!(record.state, RequestState::Failed);
 +        assert_eq!(record.owner.sender, ":1.42");
 +        assert_eq!(record.owner.app_id.as_deref(), Some("org.test.App"));
 +        assert_eq!(
 +            record.parent_window,
 +            Some(ParentWindowContext::X11 { window_id: 42 })
 +        );
 +    }
++
 +    #[test]
 +    fn register_unimplemented_call_is_idempotent_for_same_identity() {
 +        let mut dispatch = new_dispatch();
 +        dispatch
 +            .register_unimplemented_call("req:1_42:token_1", ":1.42", "org.test.App", "")
 +            .expect("first register");
 +        dispatch
 +            .register_unimplemented_call("req:1_42:token_1", ":1.42", "org.test.App", "")
 +            .expect("second register");
++
 +        let record = dispatch
 +            .record("req:1_42:token_1")
 +            .expect("record should exist");
 +        assert_eq!(record.state, RequestState::Failed);
 +    }
++
 +    #[test]
 +    fn register_unimplemented_call_rejects_owner_mismatch() {
 +        let mut dispatch = new_dispatch();
 +        dispatch
 +            .register_unimplemented_call("req:1_42:token_1", ":1.42", "org.test.App", "")
 +            .expect("first register");
++
 +        let result =
 +            dispatch.register_unimplemented_call("req:1_42:token_1", ":1.43", "org.test.App", "");
 +        assert_eq!(result, Err(PortalError::OwnershipMismatch));
 +    }
++
 +    #[test]
 +    fn register_unimplemented_call_rejects_invalid_parent_window() {
 +        let mut dispatch = new_dispatch();
 +        let result = dispatch.register_unimplemented_call(
 +            "req:1_42:token_1",
 +            ":1.42",
 +            "org.test.App",
 +            "wayland:surface",
 +        );
 +        assert_eq!(result, Err(PortalError::InvalidParentWindow));
 +    }
++
 +    #[test]
 +    fn update_choices_rejects_terminal_request() {
 +        let mut dispatch = new_dispatch();
 +        dispatch
 +            .register_unimplemented_call("req:1_42:token_1", ":1.42", "org.test.App", "")
 +            .expect("register request");
++
 +        let result = dispatch.validate_update_choices("req:1_42:token_1", ":1.42");
 +        assert_eq!(result, Err(PortalError::InvalidTransition));
 +    }
++
 +    fn new_dispatch() -> PortalDispatch {
 +        PortalDispatch::new(Duration::from_secs(30))
 +    }
 +}