`265e97f`

add request list command

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

SHA: 265e97fd22c9db1b7fc4f143e153a930a97b4433
Parents: 8bc8337
Tree: a629a35

4 changed files

Status	File	+	-
M	`README.md`	2	1
M	`garwarp-ipc/src/lib.rs`	47	0
M	`garwarp/src/daemon.rs`	56	0
M	`garwarpctl/src/main.rs`	32	0

README.mdmodified

 . Verify D-Bus activation: `./scripts/test-dbus-activation.sh`
 . Create mock request: `cargo run -p garwarpctl -- begin req-1 :1.2 - x11:0x2a`
 . Transition mock request: `cargo run -p garwarpctl -- transition req-1 :1.2 awaiting_user`
 -7. Inspect request snapshot: `cargo run -p garwarpctl -- inspect req-1`
 +7. List known requests: `cargo run -p garwarpctl -- list`
 +8. Inspect request snapshot: `cargo run -p garwarpctl -- inspect req-1`
  ## Runtime Tuning
 . `GARWARP_REQUEST_TIMEOUT_MS`: timeout before in-flight requests are marked `expired`.

garwarp-ipc/src/lib.rsmodified

  pub enum ControlRequest {
      Status,
      Stop,
 +    ListRequests,
      InspectRequest {
          id: String,
      },
          match self {
              Self::Status => "status".to_string(),
              Self::Stop => "stop".to_string(),
 +            Self::ListRequests => "list".to_string(),
              Self::InspectRequest { id } => format!("inspect id={id}"),
              Self::BeginRequest {
                  id,
          if trimmed == "stop" {
              return Some(Self::Stop);
+         }
 +        if trimmed == "list" {
 +            return Some(Self::ListRequests);
 +        }
          let mut parts = trimmed.split_whitespace();
          match parts.next() {
  pub enum ControlResponse {
      Status(StatusResponse),
      AckStopping,
 +    RequestList {
 +        ids: Vec<String>,
 +    },
      AckRequest {
          id: String,
          state: String,
                  status.in_flight_requests
              ),
              Self::AckStopping => "ack stopping\n".to_string(),
 +            Self::RequestList { ids } => {
 +                let ids = if ids.is_empty() {
 +                    "-".to_string()
 +                } else {
 +                    ids.join(",")
 +                };
 +                format!("list ids={ids}\n")
 +            }
              Self::AckRequest { id, state } => {
                  format!("ack request id={} state={}\n", id, state)
+             }
                  Some(other) => Err(ParseError::UnknownToken(other.to_string())),
                  None => Err(ParseError::MissingField("ack")),
              },
 +            Some("list") => {
 +                let mut ids = None;
 +                for part in parts {
 +                    let (key, value) = part
 +                        .split_once('=')
 +                        .ok_or(ParseError::InvalidField(part.to_string()))?;
 +                    match key {
 +                        "ids" => {
 +                            if value == "-" {
 +                                ids = Some(Vec::new());
 +                            } else {
 +                                let parsed =
 +                                    value.split(',').map(str::to_string).collect::<Vec<_>>();
 +                                if parsed.iter().any(|id| id.is_empty()) {
 +                                    return Err(ParseError::InvalidField(part.to_string()));
 +                                }
 +                                ids = Some(parsed);
 +                            }
 +                        }
 +                        _ => return Err(ParseError::InvalidField(part.to_string())),
 +                    }
 +                }
 +                Ok(Self::RequestList {
 +                    ids: ids.ok_or(ParseError::MissingField("ids"))?,
 +                })
 +            }
              Some("snapshot") => {
                  let mut id = None;
                  let mut state = None;
          for request in [
              ControlRequest::Status,
              ControlRequest::Stop,
 +            ControlRequest::ListRequests,
              ControlRequest::InspectRequest {
                  id: "req-1".to_string(),
              },
      fn response_ack_roundtrip() {
          for response in [
              ControlResponse::AckStopping,
 +            ControlResponse::RequestList {
 +                ids: vec!["req-1".to_string(), "req-2".to_string()],
 +            },
 +            ControlResponse::RequestList { ids: Vec::new() },
              ControlResponse::AckRequest {
                  id: "req-1".to_string(),
                  state: "pending".to_string(),

garwarp/src/daemon.rsmodified

              state.running = false;
              ControlResponse::AckStopping
+         }
 +        Some(ControlRequest::ListRequests) => {
 +            let ids = state
 +                .requests
 +                .records()
 +                .into_iter()
 +                .map(|record| record.id)
 +                .collect::<Vec<_>>();
 +            ControlResponse::RequestList { ids }
 +        }
          Some(ControlRequest::InspectRequest { id }) => {
              let validation = validate_request_id(&id);
              if let Err(error) = validation {
          assert!(!state.running);
+     }
 +    #[test]
 +    fn list_requests_returns_sorted_ids() {
 +        let (mut client, server) = UnixStream::pair().expect("pair should be created");
 +        client
 +            .write_all(b"list\n")
 +            .expect("list request should be written");
++
 +        let mut state = DaemonState {
 +            health: HealthStatus::Healthy,
 +            requests: RequestRegistry::new(Duration::from_secs(5)),
 +            running: true,
 +        };
 +        state
 +            .requests
 +            .begin_at(
 +                "req-b",
 +                RequestOwner::new(":1.2", None),
 +                None,
 +                Instant::now(),
 +            )
 +            .expect("request should be created");
 +        state
 +            .requests
 +            .begin_at(
 +                "req-a",
 +                RequestOwner::new(":1.3", None),
 +                None,
 +                Instant::now(),
 +            )
 +            .expect("request should be created");
++
 +        handle_connection(server, &mut state).expect("list should be handled");
++
 +        let mut response_line = String::new();
 +        let mut reader = BufReader::new(client);
 +        reader
 +            .read_line(&mut response_line)
 +            .expect("response should be readable");
 +        let response = ControlResponse::parse_line(&response_line).expect("response should parse");
 +        assert_eq!(
 +            response,
 +            ControlResponse::RequestList {
 +                ids: vec!["req-a".to_string(), "req-b".to_string()],
 +            }
 +        );
 +    }
++
      #[test]
      fn invalid_request_uses_stable_error_reason() {
          let (mut client, server) = UnixStream::pair().expect("pair should be created");

garwarpctl/src/main.rsmodified

  enum Command {
      Status,
      Stop,
 +    List,
      Inspect {
          id: String,
      },
          [] => Ok(Command::Status),
          [command] if command == "status" => Ok(Command::Status),
          [command] if command == "stop" => Ok(Command::Stop),
 +        [command] if command == "list" => Ok(Command::List),
          [command, id] if command == "inspect" => Ok(Command::Inspect { id: id.clone() }),
          [command] if command == "version" || command == "--version" || command == "-V" => {
              Ok(Command::Version)
                  )),
+             }
+         }
 +        Command::List => {
 +            let response = send_request(ControlRequest::ListRequests)?;
 +            match response {
 +                ControlResponse::RequestList { ids } => {
 +                    if ids.is_empty() {
 +                        println!("ids=-");
 +                    } else {
 +                        for id in ids {
 +                            println!("id={id}");
 +                        }
 +                    }
 +                    Ok(())
 +                }
 +                ControlResponse::Error { code, reason } => Err(io::Error::other(format!(
 +                    "daemon error: code={code} reason={reason}"
 +                ))),
 +                other => Err(io::Error::new(
 +                    io::ErrorKind::InvalidData,
 +                    format!("unexpected response: {other:?}"),
 +                )),
 +            }
 +        }
          Command::Inspect { id } => {
              let response = send_request(ControlRequest::InspectRequest { id })?;
              match response {
      println!("commands:");
      println!("  status (default)");
      println!("  stop");
 +    println!("  list");
      println!("  inspect <id>");
      println!("  begin <id> <sender> [app_id|-] [parent_window|-]");
      println!("  transition <id> <sender> <awaiting_user|fulfilled|cancelled|failed> [app_id|-]");
          );
+     }
 +    #[test]
 +    fn parse_list_command() {
 +        let args = vec!["list".to_string()];
 +        let command = parse_command(&args).expect("list command should parse");
 +        assert_eq!(command, Command::List);
 +    }
++
      #[test]
      fn parse_transition_target_rejects_unknown_state() {
          let parsed = parse_transition_target("bogus");