Add option to disable non deterministic checks on payloads (#48)

slinkydeveloper · web-flow · commit 496c9f63e3b6 · 2025-08-14T14:49:12.000+02:00
diff --git a/src/lib.rs b/src/lib.rs
@@ -200,9 +200,19 @@ pub enum ImplicitCancellationOption {
     },
 }
 
+#[derive(Debug, Default)]
+pub enum NonDeterministicChecksOption {
+    /// This will disable checking payloads (state values, rpc request, complete awakeable value),
+    /// but will still check all the other commands parameters.
+    PayloadChecksDisabled,
+    #[default]
+    Enabled,
+}
+
 #[derive(Debug)]
 pub struct VMOptions {
     pub implicit_cancellation: ImplicitCancellationOption,
+    pub non_determinism_checks: NonDeterministicChecksOption,
 }
 
 impl Default for VMOptions {
@@ -212,6 +222,7 @@ impl Default for VMOptions {
                 cancel_children_calls: true,
                 cancel_children_one_way_calls: false,
             },
+            non_determinism_checks: NonDeterministicChecksOption::Enabled,
         }
     }
 }
diff --git a/src/service_protocol/messages.rs b/src/service_protocol/messages.rs
@@ -17,7 +17,7 @@ pub trait NamedCommandMessage {
 }
 
 pub trait CommandMessageHeaderEq {
-    fn header_eq(&self, other: &Self) -> bool;
+    fn header_eq(&self, other: &Self, ignore_payload_equality: bool) -> bool;
 }
 
 pub trait CommandMessageHeaderDiff {
@@ -36,6 +36,10 @@ macro_rules! impl_message_traits {
     ($name:ident: command) => {
         impl_message_traits!($name: message);
         impl_message_traits!($name: named_command);
+    };
+    ($name:ident: command eq) => {
+        impl_message_traits!($name: message);
+        impl_message_traits!($name: named_command);
         impl_message_traits!($name: command_header_eq);
     };
     ($name:ident: message) => {
@@ -54,7 +58,7 @@ macro_rules! impl_message_traits {
     };
     ($name:ident: command_header_eq) => {
         impl CommandMessageHeaderEq for paste! { [<$name Message>] } {
-            fn header_eq(&self, other: &Self) -> bool {
+            fn header_eq(&self, other: &Self, _: bool) -> bool {
                 self.eq(other)
             }
         }
@@ -69,53 +73,140 @@ impl_message_traits!(End: core);
 impl_message_traits!(ProposeRunCompletion: core);
 
 // -- Entries
-impl_message_traits!(InputCommand: message);
-impl_message_traits!(InputCommand: named_command);
+impl_message_traits!(InputCommand: command);
 impl CommandMessageHeaderEq for InputCommandMessage {
-    fn header_eq(&self, _: &Self) -> bool {
+    fn header_eq(&self, _: &Self, _: bool) -> bool {
         true
     }
 }
 
 impl_message_traits!(OutputCommand: command);
-impl_message_traits!(GetLazyStateCommand: command);
+impl CommandMessageHeaderEq for OutputCommandMessage {
+    fn header_eq(&self, other: &Self, ignore_payload_checks: bool) -> bool {
+        if ignore_payload_checks {
+            self.name == other.name
+                && match (&self.result, &other.result) {
+                    (
+                        Some(output_command_message::Result::Value(_)),
+                        Some(output_command_message::Result::Value(_)),
+                    ) => true,
+                    (x, y) => x.eq(y),
+                }
+        } else {
+            self.eq(other)
+        }
+    }
+}
+
+impl_message_traits!(GetLazyStateCommand: command eq);
 impl_message_traits!(GetLazyStateCompletionNotification: notification);
+
 impl_message_traits!(SetStateCommand: command);
-impl_message_traits!(ClearStateCommand: command);
-impl_message_traits!(ClearAllStateCommand: command);
-impl_message_traits!(GetLazyStateKeysCommand: command);
+impl CommandMessageHeaderEq for SetStateCommandMessage {
+    fn header_eq(&self, other: &Self, ignore_payload_checks: bool) -> bool {
+        if ignore_payload_checks {
+            self.name == other.name
+                && self.key == other.key
+                && match (&self.value, &other.value) {
+                    (Some(_), Some(_)) => true,
+                    (x, y) => x.eq(y),
+                }
+        } else {
+            self.eq(other)
+        }
+    }
+}
+
+impl_message_traits!(ClearStateCommand: command eq);
+
+impl_message_traits!(ClearAllStateCommand: command eq);
+
+impl_message_traits!(GetLazyStateKeysCommand: command eq);
 impl_message_traits!(GetLazyStateKeysCompletionNotification: notification);
+
 impl_message_traits!(GetEagerStateCommand: command);
-impl_message_traits!(GetEagerStateKeysCommand: command);
-impl_message_traits!(GetPromiseCommand: command);
+impl CommandMessageHeaderEq for GetEagerStateCommandMessage {
+    fn header_eq(&self, other: &Self, ignore_payload_checks: bool) -> bool {
+        if ignore_payload_checks {
+            self.name == other.name
+                && self.key == other.key
+                && match (&self.result, &other.result) {
+                    (
+                        Some(get_eager_state_command_message::Result::Value(_)),
+                        Some(get_eager_state_command_message::Result::Value(_)),
+                    ) => true,
+                    (x, y) => x.eq(y),
+                }
+        } else {
+            self.eq(other)
+        }
+    }
+}
+
+impl_message_traits!(GetEagerStateKeysCommand: command eq);
+
+impl_message_traits!(GetPromiseCommand: command eq);
 impl_message_traits!(GetPromiseCompletionNotification: notification);
-impl_message_traits!(PeekPromiseCommand: command);
+
+impl_message_traits!(PeekPromiseCommand: command eq);
 impl_message_traits!(PeekPromiseCompletionNotification: notification);
+
 impl_message_traits!(CompletePromiseCommand: command);
+impl CommandMessageHeaderEq for CompletePromiseCommandMessage {
+    fn header_eq(&self, other: &Self, ignore_payload_checks: bool) -> bool {
+        if ignore_payload_checks {
+            self.name == other.name
+                && self.key == other.key
+                && self.result_completion_id == other.result_completion_id
+                && match (&self.completion, &other.completion) {
+                    (
+                        Some(complete_promise_command_message::Completion::CompletionValue(_)),
+                        Some(complete_promise_command_message::Completion::CompletionValue(_)),
+                    ) => true,
+                    (x, y) => x.eq(y),
+                }
+        } else {
+            self.eq(other)
+        }
+    }
+}
 impl_message_traits!(CompletePromiseCompletionNotification: notification);
 
-impl_message_traits!(SleepCommand: message);
-impl_message_traits!(SleepCommand: named_command);
+impl_message_traits!(SleepCommand: command);
 impl CommandMessageHeaderEq for SleepCommandMessage {
-    fn header_eq(&self, other: &Self) -> bool {
+    fn header_eq(&self, other: &Self, _: bool) -> bool {
         self.name == other.name
     }
 }
-
 impl_message_traits!(SleepCompletionNotification: notification);
+
 impl_message_traits!(CallCommand: command);
+impl CommandMessageHeaderEq for CallCommandMessage {
+    fn header_eq(&self, other: &Self, ignore_payload_checks: bool) -> bool {
+        self.service_name == other.service_name
+            && self.handler_name == other.handler_name
+            && (ignore_payload_checks || (self.parameter == other.parameter))
+            && self.headers == other.headers
+            && self.key == other.key
+            && self.idempotency_key == other.idempotency_key
+            && self.invocation_id_notification_idx == other.invocation_id_notification_idx
+            && self.result_completion_id == other.result_completion_id
+            && self.name == other.name
+    }
+}
 impl_message_traits!(CallInvocationIdCompletionNotification: notification);
 impl_message_traits!(CallCompletionNotification: notification);
 
-impl_message_traits!(OneWayCallCommand: message);
-impl_message_traits!(OneWayCallCommand: named_command);
+impl_message_traits!(OneWayCallCommand: command);
 impl CommandMessageHeaderEq for OneWayCallCommandMessage {
-    fn header_eq(&self, other: &Self) -> bool {
+    fn header_eq(&self, other: &Self, ignore_payload_checks: bool) -> bool {
         self.service_name == other.service_name
             && self.handler_name == other.handler_name
-            && self.key == other.key
+            && (ignore_payload_checks || (self.parameter == other.parameter))
             && self.headers == other.headers
-            && self.parameter == other.parameter
+            && self.key == other.key
+            && self.idempotency_key == other.idempotency_key
+            && self.invocation_id_notification_idx == other.invocation_id_notification_idx
             && self.name == other.name
     }
 }
@@ -128,13 +219,34 @@ impl NamedCommandMessage for SendSignalCommandMessage {
 }
 impl_message_traits!(SendSignalCommand: command_header_eq);
 
-impl_message_traits!(RunCommand: command);
+impl_message_traits!(RunCommand: command eq);
 impl_message_traits!(RunCompletionNotification: notification);
-impl_message_traits!(AttachInvocationCommand: command);
+
+impl_message_traits!(AttachInvocationCommand: command eq);
 impl_message_traits!(AttachInvocationCompletionNotification: notification);
-impl_message_traits!(GetInvocationOutputCommand: command);
+
+impl_message_traits!(GetInvocationOutputCommand: command eq);
 impl_message_traits!(GetInvocationOutputCompletionNotification: notification);
+
 impl_message_traits!(CompleteAwakeableCommand: command);
+impl CommandMessageHeaderEq for CompleteAwakeableCommandMessage {
+    fn header_eq(&self, other: &Self, ignore_payload_checks: bool) -> bool {
+        if ignore_payload_checks {
+            self.name == other.name
+                && self.awakeable_id == other.awakeable_id
+                && match (&self.result, &other.result) {
+                    (
+                        Some(complete_awakeable_command_message::Result::Value(_)),
+                        Some(complete_awakeable_command_message::Result::Failure(_)),
+                    ) => true,
+                    (x, y) => x.eq(y),
+                }
+        } else {
+            self.eq(other)
+        }
+    }
+}
+
 impl_message_traits!(SignalNotification: notification);
 
 // --- Diffs and Formatting
diff --git a/src/tests/failures.rs b/src/tests/failures.rs
@@ -1,9 +1,11 @@
 use super::*;
 
 use crate::error::CommandMetadata;
+use crate::service_protocol::messages::start_message::StateEntry;
 use crate::service_protocol::messages::{
-    CommandMessageHeaderDiff, ErrorMessage, GetLazyStateCommandMessage, OneWayCallCommandMessage,
-    StartMessage,
+    CallCommandMessage, CommandMessageHeaderDiff, EndMessage, ErrorMessage,
+    GetEagerStateCommandMessage, GetLazyStateCommandMessage, OneWayCallCommandMessage,
+    SetStateCommandMessage, StartMessage,
 };
 use crate::service_protocol::MessageType;
 use std::fmt;
@@ -159,3 +161,104 @@ fn test_entry_mismatch_on_replay<
     );
     assert_eq!(output.next(), None);
 }
+
+#[test]
+fn disable_non_deterministic_payload_checks() {
+    let mut output = VMTestCase::with_vm_options(VMOptions {
+        non_determinism_checks: NonDeterministicChecksOption::PayloadChecksDisabled,
+        ..VMOptions::default()
+    })
+    .input(StartMessage {
+        id: Bytes::from_static(b"123"),
+        debug_id: "123".to_string(),
+        known_entries: 5,
+        partial_state: true,
+        state_map: vec![StateEntry {
+            key: Bytes::from_static(b"STATE"),
+            // NOTE: this is different payload than the one recorded in the entry!
+            value: Bytes::from_static(b"456"),
+        }],
+        ..Default::default()
+    })
+    .input(input_entry_message(b"my-data"))
+    .input(OneWayCallCommandMessage {
+        service_name: "greeter".to_owned(),
+        handler_name: "greet".to_owned(),
+        key: "my-key".to_owned(),
+        parameter: Bytes::from_static(b"123"),
+        invocation_id_notification_idx: 1,
+        ..Default::default()
+    })
+    .input(CallCommandMessage {
+        service_name: "greeter".to_owned(),
+        handler_name: "greet".to_owned(),
+        key: "my-key".to_owned(),
+        parameter: Bytes::from_static(b"123"),
+        invocation_id_notification_idx: 2,
+        result_completion_id: 3,
+        ..Default::default()
+    })
+    .input(SetStateCommandMessage {
+        key: Bytes::from_static(b"my-key"),
+        value: Some(messages::Value {
+            content: Bytes::from_static(b"123"),
+        }),
+        ..Default::default()
+    })
+    .input(GetEagerStateCommandMessage {
+        key: Bytes::from_static(b"STATE"),
+        result: Some(messages::get_eager_state_command_message::Result::Value(
+            messages::Value {
+                content: Bytes::from_static(b"123"),
+            },
+        )),
+        ..Default::default()
+    })
+    .run(|vm| {
+        vm.sys_input().unwrap();
+
+        vm.sys_send(
+            Target {
+                service: "greeter".to_owned(),
+                handler: "greet".to_owned(),
+                key: Some("my-key".to_owned()),
+                idempotency_key: None,
+                headers: Vec::new(),
+            },
+            // NOTE: this is different payload!
+            Bytes::from_static(b"456"),
+            None,
+        )
+        .unwrap();
+
+        vm.sys_call(
+            Target {
+                service: "greeter".to_owned(),
+                handler: "greet".to_owned(),
+                key: Some("my-key".to_owned()),
+                idempotency_key: None,
+                headers: Vec::new(),
+            },
+            // NOTE: this is different payload!
+            Bytes::from_static(b"456"),
+        )
+        .unwrap();
+
+        vm.sys_state_set(
+            "my-key".to_owned(),
+            // NOTE: this is different payload!
+            Bytes::from_static(b"456"),
+        )
+        .unwrap();
+
+        vm.sys_state_get("STATE".to_owned()).unwrap();
+
+        vm.sys_end().unwrap();
+    });
+
+    assert_eq!(
+        output.next_decoded::<EndMessage>().unwrap(),
+        EndMessage::default()
+    );
+    assert_eq!(output.next(), None);
+}
diff --git a/src/tests/implicit_cancellation.rs b/src/tests/implicit_cancellation.rs
@@ -192,6 +192,7 @@ fn call_then_then_cancel_disabling_children_cancellation() {
             cancel_children_calls: false,
             cancel_children_one_way_calls: true,
         },
+        ..VMOptions::default()
     })
     .input(start_message(1))
     .input(input_entry_message(b"my-data"))
@@ -240,6 +241,7 @@ fn call_then_then_cancel_disabling_children_cancellation() {
 fn disabled_implicit_cancellation() {
     let mut output = VMTestCase::with_vm_options(VMOptions {
         implicit_cancellation: ImplicitCancellationOption::Disabled,
+        ..VMOptions::default()
     })
     .input(start_message(1))
     .input(input_entry_message(b"my-data"))
diff --git a/src/vm/context.rs b/src/vm/context.rs
@@ -438,6 +438,7 @@ pub(crate) struct Context {
     pub(crate) input_is_closed: bool,
     pub(crate) output: Output,
     pub(crate) eager_state: EagerState,
+    pub(crate) non_deterministic_checks_ignore_payload_equality: bool,
 }
 
 impl Context {
diff --git a/src/vm/mod.rs b/src/vm/mod.rs
diff --git a/src/vm/transitions/journal.rs b/src/vm/transitions/journal.rs

Original file line number	Diff line number	Diff line change
`@@ -200,9 +200,19 @@ pub enum ImplicitCancellationOption {`
`200`	`200`	`},`
`201`	`201`	`}`
`202`	`202`
	`203`	`+#[derive(Debug, Default)]`
	`204`	`+pub enum NonDeterministicChecksOption {`
	`205`	`+ /// This will disable checking payloads (state values, rpc request, complete awakeable value),`
	`206`	`+ /// but will still check all the other commands parameters.`
	`207`	`+ PayloadChecksDisabled,`
	`208`	`+ #[default]`
	`209`	`+ Enabled,`
	`210`	`+}`
	`211`	`+`
`203`	`212`	`#[derive(Debug)]`
`204`	`213`	`pub struct VMOptions {`
`205`	`214`	`pub implicit_cancellation: ImplicitCancellationOption,`
	`215`	`+ pub non_determinism_checks: NonDeterministicChecksOption,`
`206`	`216`	`}`
`207`	`217`
`208`	`218`	`impl Default for VMOptions {`
`@@ -212,6 +222,7 @@ impl Default for VMOptions {`
`212`	`222`	`cancel_children_calls: true,`
`213`	`223`	`cancel_children_one_way_calls: false,`
`214`	`224`	`},`
	`225`	`+ non_determinism_checks: NonDeterministicChecksOption::Enabled,`
`215`	`226`	`}`
`216`	`227`	`}`
`217`	`228`	`}`
Original file line number	Diff line number	Diff line change
`@@ -438,6 +438,7 @@ pub(crate) struct Context {`
`438`	`438`	`pub(crate) input_is_closed: bool,`
`439`	`439`	`pub(crate) output: Output,`
`440`	`440`	`pub(crate) eager_state: EagerState,`
	`441`	`+ pub(crate) non_deterministic_checks_ignore_payload_equality: bool,`
`441`	`442`	`}`
`442`	`443`
`443`	`444`	`impl Context {`