`5c14533`

add portal smoke command

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

SHA: 5c14533447cc2ccce99d81d7c9a893a840f05935
Parents: 1fd4b17
Tree: b96cd5b

3 changed files

Status	File	+	-
M	`Cargo.lock`	1	0
M	`garwarpctl/Cargo.toml`	1	0
M	`garwarpctl/src/main.rs`	192	1

Cargo.lockmodified


 version = "0.1.0"
 dependencies = [
  "garwarp-ipc",
+ "zbus",
 ]
 
 [[package]]

garwarpctl/Cargo.tomlmodified

`@@ -5,3 +5,4 @@` edition = "2024"
5		5
6	[dependencies]	6	[dependencies]
7	garwarp-ipc = { path = "../garwarp-ipc" }	7	garwarp-ipc = { path = "../garwarp-ipc" }
		8	+zbus = "5.14.0"

garwarpctl/src/main.rsmodified

++use std::collections::HashMap;
  use std::env;
  use std::io::{self, BufRead, BufReader, Write};
  use std::os::unix::net::UnixStream;
      ControlRequest, ControlResponse, DEFAULT_CONTROL_SOCKET, DEFAULT_RUNTIME_SUBDIR,
      PROTOCOL_VERSION, RequestTransitionTarget,
  };
++use zbus::{
++    blocking::Connection,
++    zvariant::{OwnedObjectPath, OwnedValue},
++};
++
++const BACKEND_DBUS_NAME: &str = "org.freedesktop.impl.portal.desktop.garwarp";
++const BACKEND_OBJECT_PATH: &str = "/org/freedesktop/portal/desktop";
++const PORTAL_RESPONSE_FAILED: u32 = 2;
  fn main() {
      let args: Vec<String> = env::args().collect();
      Status,
      Stop,
      List,
++    PortalSmoke,
      Inspect {
          id: String,
      },
          [command] if command == "status" => Ok(Command::Status),
          [command] if command == "stop" => Ok(Command::Stop),
          [command] if command == "list" => Ok(Command::List),
++        [command] if command == "portal-smoke" => Ok(Command::PortalSmoke),
          [command, id] if command == "inspect" => Ok(Command::Inspect { id: id.clone() }),
          [command] if command == "version" || command == "--version" || command == "-V" => {
              Ok(Command::Version)
                  )),
+             }
+         }
++        Command::PortalSmoke => run_portal_smoke(),
          Command::Inspect { id } => {
              let response = send_request(ControlRequest::InspectRequest { id })?;
              match response {
+     }
+ }
++fn run_portal_smoke() -> io::Result<()> {
++    let connection = Connection::session()
++        .map_err(|error| io::Error::other(format!("failed to connect to session bus: {error}")))?;
++    let sender = connection
++        .unique_name()
++        .ok_or_else(|| io::Error::other("connection missing unique bus name"))?
++        .as_str()
++        .to_string();
++    let sender_segment = sender_to_handle_segment(&sender)?;
++
++    let screenshot_handle = request_handle(&sender_segment, "smoke_screenshot")?;
++    let screenshot_response = call_portal_screenshot(&connection, screenshot_handle)?;
++    println!("screenshot_response={screenshot_response}");
++
++    let open_file_handle = request_handle(&sender_segment, "smoke_open_file")?;
++    let open_file_response = call_portal_open_file(&connection, open_file_handle)?;
++    println!("open_file_response={open_file_response}");
++
++    let choose_handle = request_handle(&sender_segment, "smoke_choose_app")?;
++    let choose_response = call_portal_choose_application(&connection, choose_handle.clone())?;
++    println!("choose_application_response={choose_response}");
++
++    call_portal_update_choices_expect_invalid_transition(&connection, choose_handle)?;
++    println!("update_choices=invalid_transition");
++    println!("portal_smoke=ok");
++    Ok(())
++}
++
++fn sender_to_handle_segment(sender: &str) -> io::Result<String> {
++    let sender = sender.strip_prefix(':').ok_or_else(|| {
++        io::Error::new(
++            io::ErrorKind::InvalidInput,
++            format!("invalid sender unique name: {sender}"),
++        )
++    })?;
++    if sender.is_empty() {
++        return Err(io::Error::new(
++            io::ErrorKind::InvalidInput,
++            "invalid sender unique name: empty".to_string(),
++        ));
++    }
++
++    let mut segment = String::with_capacity(sender.len());
++    for ch in sender.chars() {
++        if ch.is_ascii_alphanumeric() {
++            segment.push(ch);
++            continue;
++        }
++        if matches!(ch, '.' | '_' | '-') {
++            segment.push('_');
++            continue;
++        }
++        return Err(io::Error::new(
++            io::ErrorKind::InvalidInput,
++            format!("unsupported sender character: {ch}"),
++        ));
++    }
++
++    Ok(segment)
++}
++
++fn request_handle(sender_segment: &str, token: &str) -> io::Result<OwnedObjectPath> {
++    let path = format!("{BACKEND_OBJECT_PATH}/request/{sender_segment}/{token}");
++    OwnedObjectPath::try_from(path.clone()).map_err(|error| {
++        io::Error::new(
++            io::ErrorKind::InvalidInput,
++            format!("invalid request-handle path {path}: {error}"),
++        )
++    })
++}
++
++fn empty_options() -> HashMap<String, OwnedValue> {
++    HashMap::new()
++}
++
++fn call_portal_screenshot(connection: &Connection, handle: OwnedObjectPath) -> io::Result<u32> {
++    let message = connection
++        .call_method(
++            Some(BACKEND_DBUS_NAME),
++            BACKEND_OBJECT_PATH,
++            Some("org.freedesktop.impl.portal.Screenshot"),
++            "Screenshot",
++            &(handle, "org.test.App", "", empty_options()),
++        )
++        .map_err(|error| io::Error::other(format!("screenshot call failed: {error}")))?;
++    expect_failed_response(message)
++}
++
++fn call_portal_open_file(connection: &Connection, handle: OwnedObjectPath) -> io::Result<u32> {
++    let message = connection
++        .call_method(
++            Some(BACKEND_DBUS_NAME),
++            BACKEND_OBJECT_PATH,
++            Some("org.freedesktop.impl.portal.FileChooser"),
++            "OpenFile",
++            &(handle, "org.test.App", "", "Open", empty_options()),
++        )
++        .map_err(|error| io::Error::other(format!("open file call failed: {error}")))?;
++    expect_failed_response(message)
++}
++
++fn call_portal_choose_application(
++    connection: &Connection,
++    handle: OwnedObjectPath,
++) -> io::Result<u32> {
++    let choices = vec!["org.test.Viewer".to_string()];
++    let message = connection
++        .call_method(
++            Some(BACKEND_DBUS_NAME),
++            BACKEND_OBJECT_PATH,
++            Some("org.freedesktop.impl.portal.AppChooser"),
++            "ChooseApplication",
++            &(handle, "org.test.App", "", choices, empty_options()),
++        )
++        .map_err(|error| io::Error::other(format!("choose application call failed: {error}")))?;
++    expect_failed_response(message)
++}
++
++fn call_portal_update_choices_expect_invalid_transition(
++    connection: &Connection,
++    handle: OwnedObjectPath,
++) -> io::Result<()> {
++    let choices = vec!["org.test.Viewer".to_string()];
++    match connection.call_method(
++        Some(BACKEND_DBUS_NAME),
++        BACKEND_OBJECT_PATH,
++        Some("org.freedesktop.impl.portal.AppChooser"),
++        "UpdateChoices",
++        &(handle, choices),
++    ) {
++        Ok(_) => Err(io::Error::other(
++            "expected UpdateChoices to fail with invalid_transition".to_string(),
++        )),
++        Err(error) => {
++            let text = error.to_string();
++            if !text.contains("invalid_transition") {
++                return Err(io::Error::other(format!(
++                    "unexpected UpdateChoices error: {text}"
++                )));
++            }
++            Ok(())
++        }
++    }
++}
++
++fn expect_failed_response(message: zbus::message::Message) -> io::Result<u32> {
++    let (response, results): (u32, HashMap<String, OwnedValue>) = message
++        .body()
++        .deserialize()
++        .map_err(|error| io::Error::other(format!("failed to decode method reply: {error}")))?;
++    if response != PORTAL_RESPONSE_FAILED {
++        return Err(io::Error::other(format!(
++            "unexpected portal response code: {response}"
++        )));
++    }
++    if !results.is_empty() {
++        return Err(io::Error::other(
++            "expected empty results map for placeholder implementation".to_string(),
++        ));
++    }
++    Ok(response)
++}
++
  fn send_request(request: ControlRequest) -> io::Result<ControlResponse> {
      let socket_path = control_socket_path();
      let mut stream = UnixStream::connect(&socket_path)?;
      println!("  status (default)");
      println!("  stop");
      println!("  list");
++    println!("  portal-smoke");
      println!("  inspect <id>");
      println!("  begin <id> <sender> [app_id|-] [parent_window|-]");
      println!("  transition <id> <sender> <awaiting_user|fulfilled|cancelled|failed> [app_id|-]");
  #[cfg(test)]
  mod tests {
--    use super::{Command, optional_value, parse_command, parse_transition_target};
++    use super::{
++        Command, optional_value, parse_command, parse_transition_target, sender_to_handle_segment,
++    };
      use garwarp_ipc::RequestTransitionTarget;
      #[test]
          assert_eq!(command, Command::List);
+     }
++    #[test]
++    fn parse_portal_smoke_command() {
++        let args = vec!["portal-smoke".to_string()];
++        let command = parse_command(&args).expect("portal-smoke command should parse");
++        assert_eq!(command, Command::PortalSmoke);
++    }
++
      #[test]
      fn parse_transition_target_rejects_unknown_state() {
          let parsed = parse_transition_target("bogus");
              Some("org.test.App".to_string())
          );
+     }
++
++    #[test]
++    fn sender_segment_is_derived_from_unique_name() {
++        let segment = sender_to_handle_segment(":1.42").expect("segment should parse");
++        assert_eq!(segment, "1_42");
++    }
+ }

`@@ -316,6 +316,7 @@` name = "garwarpctl"
316	version = "0.1.0"	316	version = "0.1.0"
317	dependencies = [	317	dependencies = [
318	"garwarp-ipc",	318	"garwarp-ipc",
		319	+ "zbus",
319	]	320	]
320		321
321	[[package]]	322	[[package]]