`8060762`

add status request counters

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

SHA: 8060762e00ac3772f5daca7c903fdc48e53f8871
Parents: c0fb997
Tree: 736ca2f

5 changed files

Status	File	+	-
M	`README.md`	1	1
M	`garwarp-ipc/src/lib.rs`	34	3
M	`garwarp/src/daemon.rs`	4	0
M	`garwarp/src/request.rs`	32	0
M	`garwarpctl/src/main.rs`	2	0

README.mdmodified

  ## Local Commands
 . Start daemon: `cargo run -p garwarp -- daemon`
 -2. Check health: `cargo run -p garwarpctl -- status`
 +2. Check health and request counters: `cargo run -p garwarpctl -- status`
 . Stop daemon: `cargo run -p garwarpctl -- stop`
 . Verify D-Bus activation: `./scripts/test-dbus-activation.sh`
 . Create mock request: `cargo run -p garwarpctl -- begin req-1 :1.2 - x11:0x2a`

garwarp-ipc/src/lib.rsmodified

      pub protocol_version: u16,
      pub health: HealthStatus,
      pub in_flight_requests: usize,
 +    pub total_requests: usize,
 +    pub terminal_requests: usize,
+ }
  impl StatusResponse {
              protocol_version: PROTOCOL_VERSION,
              health: HealthStatus::Healthy,
              in_flight_requests: 0,
 +            total_requests: 0,
 +            terminal_requests: 0,
+         }
+     }
+ }
      pub fn to_line(&self) -> String {
          match self {
              Self::Status(status) => format!(
 -                "status protocol={} health={} in_flight={}\n",
 +                "status protocol={} health={} in_flight={} total={} terminal={}\n",
                  status.protocol_version,
                  status.health.as_str(),
 -                status.in_flight_requests
 +                status.in_flight_requests,
 +                status.total_requests,
 +                status.terminal_requests
              ),
              Self::AckStopping => "ack stopping\n".to_string(),
              Self::RequestList { ids } => {
                  let mut protocol_version = None;
                  let mut health = None;
                  let mut in_flight_requests = None;
 +                let mut total_requests = None;
 +                let mut terminal_requests = None;
                  for part in parts {
                      let (key, value) = part
                                      .map_err(|_| ParseError::InvalidField(part.to_string()))?,
                              );
+                         }
 +                        "total" => {
 +                            total_requests = Some(
 +                                value
 +                                    .parse::<usize>()
 +                                    .map_err(|_| ParseError::InvalidField(part.to_string()))?,
 +                            );
 +                        }
 +                        "terminal" => {
 +                            terminal_requests = Some(
 +                                value
 +                                    .parse::<usize>()
 +                                    .map_err(|_| ParseError::InvalidField(part.to_string()))?,
 +                            );
 +                        }
                          _ => return Err(ParseError::InvalidField(part.to_string())),
+                     }
+                 }
                      health: health.ok_or(ParseError::MissingField("health"))?,
                      in_flight_requests: in_flight_requests
                          .ok_or(ParseError::MissingField("in_flight"))?,
 +                    total_requests: total_requests.ok_or(ParseError::MissingField("total"))?,
 +                    terminal_requests: terminal_requests
 +                        .ok_or(ParseError::MissingField("terminal"))?,
                  };
                  Ok(Self::Status(status))
+             }
              protocol_version: PROTOCOL_VERSION,
              health: HealthStatus::Healthy,
              in_flight_requests: 7,
 +            total_requests: 10,
 +            terminal_requests: 3,
          });
          let line = response.to_line();
          let parsed = ControlResponse::parse_line(&line).expect("response should parse");
          assert_eq!(response.protocol_version, PROTOCOL_VERSION);
          assert_eq!(response.health, HealthStatus::Healthy);
          assert_eq!(response.in_flight_requests, 0);
 +        assert_eq!(response.total_requests, 0);
 +        assert_eq!(response.terminal_requests, 0);
+     }
      #[test]
      fn malformed_status_is_rejected() {
 -        let parsed = ControlResponse::parse_line("status protocol=one health=healthy in_flight=0");
 +        let parsed = ControlResponse::parse_line(
 +            "status protocol=one health=healthy in_flight=0 total=0 terminal=0",
 +        );
          assert!(parsed.is_err());
+     }

garwarp/src/daemon.rsmodified

              protocol_version: garwarp_ipc::PROTOCOL_VERSION,
              health: state.health,
              in_flight_requests: state.requests.in_flight_count(),
 +            total_requests: state.requests.total_count(),
 +            terminal_requests: state.requests.terminal_count(),
          }),
          Some(ControlRequest::Stop) => {
              state.health = HealthStatus::Stopping;
              ControlResponse::Status(status) => {
                  assert_eq!(status.health, HealthStatus::Healthy);
                  assert_eq!(status.in_flight_requests, 1);
 +                assert_eq!(status.total_requests, 1);
 +                assert_eq!(status.terminal_requests, 0);
+             }
              _ => panic!("expected status response"),
+         }

garwarp/src/request.rsmodified

              .count()
+     }
 +    #[must_use]
 +    pub fn total_count(&self) -> usize {
 +        self.entries.len()
 +    }
++
 +    #[must_use]
 +    pub fn terminal_count(&self) -> usize {
 +        self.entries
 +            .values()
 +            .filter(|entry| entry.state.is_terminal())
 +            .count()
 +    }
++
      #[must_use]
      pub fn state(&self, id: &str) -> Option<RequestState> {
          self.entries.get(id).map(|entry| entry.state)
          assert_eq!(registry.state("req-1"), Some(RequestState::Pending));
+     }
 +    #[test]
 +    fn count_helpers_return_expected_values() {
 +        let now = Instant::now();
 +        let mut registry = RequestRegistry::new(Duration::from_secs(5));
 +        registry
 +            .begin_at("req-1", owner(":1.2"), None, now)
 +            .expect("request should be created");
 +        registry
 +            .begin_at("req-2", owner(":1.3"), None, now)
 +            .expect("request should be created");
 +        registry
 +            .transition_at("req-2", &owner(":1.3"), RequestState::Cancelled, now)
 +            .expect("request should transition");
++
 +        assert_eq!(registry.total_count(), 2);
 +        assert_eq!(registry.in_flight_count(), 1);
 +        assert_eq!(registry.terminal_count(), 1);
 +    }
++
      #[test]
      fn duplicate_cancel_is_idempotent() {
          let now = Instant::now();

garwarpctl/src/main.rsmodified

                      println!("protocol={}", status.protocol_version);
                      println!("health={}", status.health.as_str());
                      println!("in_flight={}", status.in_flight_requests);
 +                    println!("total={}", status.total_requests);
 +                    println!("terminal={}", status.terminal_requests);
                      Ok(())
+                 }
                  ControlResponse::Error { code, reason } => Err(io::Error::other(format!(