add status request counters

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
 1. Start daemon: `cargo run -p garwarp -- daemon`
+2. Check health and request counters: `cargo run -p garwarpctl -- status`
 3. Stop daemon: `cargo run -p garwarpctl -- stop`
 4. Verify D-Bus activation: `./scripts/test-dbus-activation.sh`
 5. 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!(

`@@ -18,7 +18,7 @@` Current scaffold includes:
18		18
19	## Local Commands	19	## Local Commands
20	1. Start daemon: `cargo run -p garwarp -- daemon`	20	1. Start daemon: `cargo run -p garwarp -- daemon`
21	-2. Check health: `cargo run -p garwarpctl -- status`	21	+2. Check health and request counters: `cargo run -p garwarpctl -- status`
22	3. Stop daemon: `cargo run -p garwarpctl -- stop`	22	3. Stop daemon: `cargo run -p garwarpctl -- stop`
23	4. Verify D-Bus activation: `./scripts/test-dbus-activation.sh`	23	4. Verify D-Bus activation: `./scripts/test-dbus-activation.sh`
24	5. Create mock request: `cargo run -p garwarpctl -- begin req-1 :1.2 - x11:0x2a`	24	5. Create mock request: `cargo run -p garwarpctl -- begin req-1 :1.2 - x11:0x2a`

gardesk/garwarp / `8060762`

5 changed files