`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<'_>,
++    header: &Header<'_>,
--) -> Result<String, PortalError> {
++) -> 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(
--            object_server.at(BACKEND_OBJECT_PATH, FileChooserPortal)?;
++                BACKEND_OBJECT_PATH,
--            object_server.at(BACKEND_OBJECT_PATH, AppChooserPortal)?;
++                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)
++        let (sender, request_id) =
--            .map(|_| ())
++            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()))
+     }
  #[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!(
--        assert_eq!(FileChooserPortal.version(), INTERFACE_VERSION);
++            ScreenshotPortal::new(test_dispatch()).version(),
--        assert_eq!(AppChooserPortal.version(), INTERFACE_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))
++    }
++}

`@@ -5,6 +5,7 @@` mod error;
5	mod lock;	5	mod lock;
6	mod logging;	6	mod logging;
7	mod portal;	7	mod portal;
		8	+mod portal_dispatch;
8	mod portal_options;	9	mod portal_options;
9	mod request;	10	mod request;
10	mod request_store;	11	mod request_store;