`c35eb64`

make terminal transitions idempotent

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

SHA: c35eb649243aa9b8580c6b793482f6e470c79a9f
Parents: 13125f4
Tree: d1f544f

2 changed files

Status	File	+	-
M	`garwarp/src/daemon.rs`	47	0
M	`garwarp/src/request.rs`	27	0

garwarp/src/daemon.rsmodified

          assert_eq!(state.requests.state("req-1"), Some(RequestState::Pending));
+     }
++    #[test]
++    fn duplicate_cancel_returns_ack() {
++        let (mut client, server) = UnixStream::pair().expect("pair should be created");
++        client
++            .write_all(b"transition id=req-1 sender=:1.2 state=cancelled\n")
++            .expect("transition 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-1",
++                RequestOwner::new(":1.2", None),
++                None,
++                Instant::now(),
++            )
++            .expect("request should be created");
++        state
++            .requests
++            .transition(
++                "req-1",
++                &RequestOwner::new(":1.2", None),
++                RequestState::Cancelled,
++            )
++            .expect("first cancel should transition");
++        handle_connection(server, &mut state).expect("transition 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::AckRequest {
++                id: "req-1".to_string(),
++                state: "cancelled".to_string(),
++            }
++        );
++        assert_eq!(state.requests.state("req-1"), Some(RequestState::Cancelled));
++    }
++
      #[test]
      fn startup_recovery_expires_non_terminal_requests() {
          let path = unique_temp_file();

garwarp/src/request.rsmodified

              return Err(RequestError::OwnerMismatch(id.to_string()));
+         }
++        if entry.state == target && target.is_terminal() {
++            entry.last_updated_at = now;
++            return Ok(());
++        }
++
          if !is_valid_transition(entry.state, target) {
              return Err(RequestError::InvalidTransition {
                  id: id.to_string(),
          assert!(removed.is_empty());
          assert_eq!(registry.state("req-1"), Some(RequestState::Pending));
+     }
++
++    #[test]
++    fn duplicate_cancel_is_idempotent() {
++        let now = Instant::now();
++        let request_owner = owner(":1.2");
++        let mut registry = RequestRegistry::new(Duration::from_secs(5));
++        registry
++            .begin_at("req-1", request_owner.clone(), None, now)
++            .expect("request should be created");
++        registry
++            .transition_at("req-1", &request_owner, RequestState::Cancelled, now)
++            .expect("first cancel should succeed");
++        registry
++            .transition_at(
++                "req-1",
++                &request_owner,
++                RequestState::Cancelled,
++                now + Duration::from_millis(50),
++            )
++            .expect("duplicate cancel should be idempotent");
++        assert_eq!(registry.state("req-1"), Some(RequestState::Cancelled));
++    }
+ }