restate-sdk 1.2.1-aarch64-linux → 1.3.1-aarch64-linux

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/README.md CHANGED
@@ -110,7 +110,7 @@ We know that your time is precious and, therefore, deeply value any effort to co
110
110
  * Ruby >= 3.1
111
111
  * [Rust toolchain](https://rustup.rs/)
112
112
  * Docker (for integration tests)
113
- * Java 21+ (for sdk-test-suite integration tests)
113
+ * Docker is all the sdk-test-suite integration tests need (the suite runs in a Java container)
114
114
 
115
115
  Install dependencies and build:
116
116
 
@@ -125,7 +125,7 @@ Run the full verification suite (build, lint, typecheck, tests):
125
125
  make verify
126
126
  ```
127
127
 
128
- Run integration tests (requires Docker + Java 21+):
128
+ Run integration tests (requires Docker):
129
129
 
130
130
  ```shell
131
131
  make test-integration
@@ -1,7 +1,7 @@
1
1
  [package]
2
2
  name = "restate_internal"
3
- version = "1.2.1"
4
- edition = "2021"
3
+ version = "1.3.1"
4
+ edition = "2024"
5
5
  publish = false
6
6
 
7
7
  [lib]
@@ -10,7 +10,7 @@ crate-type = ["cdylib"]
10
10
  doc = false
11
11
 
12
12
  [dependencies]
13
- magnus = { version = "0.8", features = ["rb-sys"] }
13
+ magnus = { version = "0.9", features = ["rb-sys"] }
14
14
  rb-sys = { version = "0.9", features = ["stable-api-compiled-fallback"] }
15
- restate-sdk-shared-core = { version = "7.0.3" , features = ["request_identity", "sha2_random_seed", "rust_crypto"] }
15
+ restate-sdk-shared-core = { version = "8.7.1", features = ["request_identity", "sha2_random_seed", "rust_crypto"] }
16
16
  tracing-subscriber = { version = "0.3", features = ["fmt", "env-filter"] }
@@ -1,13 +1,12 @@
1
1
  use magnus::{
2
- function, method,
3
- value::ReprValue,
4
2
  Error, ExceptionClass, Module, Object, RArray, RString, Ruby, Symbol, TryConvert, Value,
3
+ function, method, value::ReprValue,
5
4
  };
6
5
  use restate_sdk_shared_core::{
7
- AwaitResponse, CallHandle, CoreVM, Error as CoreError, Header, IdentityVerifier, Input,
8
- NonEmptyValue, NotificationHandle, OnMaxAttempts, ResponseHead, RetryPolicy, RunExitResult,
9
- RunHandle, State, Target, TerminalFailure, UnresolvedFuture, VMOptions, Value as CoreValue,
10
- VM, CANCEL_NOTIFICATION_HANDLE,
6
+ AwaitResponse, CANCEL_NOTIFICATION_HANDLE, CallHandle, CoreVM, Error as CoreError, Header,
7
+ IdentityVerifier, Input, NonEmptyValue, NotificationHandle, OnMaxAttempts, ResponseHead,
8
+ RetryPolicy, RunExitResult, RunHandle, State, Target, TerminalFailure, UnresolvedFuture, VM,
9
+ VMOptions, Value as CoreValue,
11
10
  };
12
11
  use std::cell::RefCell;
13
12
  use std::fmt;
@@ -30,7 +29,10 @@ static IDENTITY_KEY_ERROR_CLASS: OnceLock<SyncExceptionClass> = OnceLock::new();
30
29
  static IDENTITY_VERIFICATION_ERROR_CLASS: OnceLock<SyncExceptionClass> = OnceLock::new();
31
30
 
32
31
  fn vm_error_class() -> ExceptionClass {
33
- VM_ERROR_CLASS.get().expect("VM_ERROR_CLASS not initialized").0
32
+ VM_ERROR_CLASS
33
+ .get()
34
+ .expect("VM_ERROR_CLASS not initialized")
35
+ .0
34
36
  }
35
37
 
36
38
  fn identity_key_error_class() -> ExceptionClass {
@@ -420,8 +422,7 @@ impl RbVM {
420
422
  let v: String = pair.entry(1)?;
421
423
  hdr_vec.push((k, v));
422
424
  }
423
- let vm =
424
- CoreVM::new(hdr_vec, VMOptions::default()).map_err(core_error_to_magnus)?;
425
+ let vm = CoreVM::new(hdr_vec, VMOptions::default()).map_err(core_error_to_magnus)?;
425
426
  Ok(Self {
426
427
  vm: RefCell::new(vm),
427
428
  })
@@ -488,14 +489,10 @@ impl RbVM {
488
489
  match res {
489
490
  Err(e) if e.is_suspended_error() => Ok(ruby.into_value(RbSuspended)),
490
491
  Err(e) => Err(core_error_to_magnus(e)),
491
- Ok(AwaitResponse::AnyCompleted) => {
492
- Ok(ruby.into_value(RbDoProgressAnyCompleted))
493
- }
494
- Ok(AwaitResponse::ExecuteRun(handle)) => Ok(ruby.into_value(
495
- RbDoProgressExecuteRun {
496
- handle: handle.into(),
497
- },
498
- )),
492
+ Ok(AwaitResponse::AnyCompleted) => Ok(ruby.into_value(RbDoProgressAnyCompleted)),
493
+ Ok(AwaitResponse::ExecuteRun(handle)) => Ok(ruby.into_value(RbDoProgressExecuteRun {
494
+ handle: handle.into(),
495
+ })),
499
496
  Ok(AwaitResponse::CancelSignalReceived) => {
500
497
  Ok(ruby.into_value(RbDoProgressCancelSignalReceived))
501
498
  }
@@ -506,6 +503,11 @@ impl RbVM {
506
503
  Ok(ruby.into_value(RbDoWaitForPendingRun))
507
504
  }
508
505
  }
506
+ // Ephemeral state is not exposed by the Ruby SDK, so this is never returned.
507
+ Ok(AwaitResponse::EphemeralNotificationReady(_)) => Err(Error::new(
508
+ vm_error_class(),
509
+ "Unexpected ephemeral notification, this is an SDK bug",
510
+ )),
509
511
  }
510
512
  }
511
513
 
@@ -523,9 +525,7 @@ impl RbVM {
523
525
  Ok(Some(CoreValue::Void)) => Ok(ruby.into_value(RbVoid)),
524
526
  Ok(Some(CoreValue::Success(b))) => Ok(ruby.str_from_slice(&b).as_value()),
525
527
  Ok(Some(CoreValue::Failure(f))) => Ok(ruby.into_value(RbFailure::from(f))),
526
- Ok(Some(CoreValue::StateKeys(keys))) => {
527
- Ok(ruby.into_value(RbStateKeys { keys }))
528
- }
528
+ Ok(Some(CoreValue::StateKeys(keys))) => Ok(ruby.into_value(RbStateKeys { keys })),
529
529
  Ok(Some(CoreValue::InvocationId(id))) => Ok(ruby.str_new(&id).as_value()),
530
530
  }
531
531
  }
@@ -543,7 +543,7 @@ impl RbVM {
543
543
  fn sys_get_state(&self, key: String) -> Result<u32, Error> {
544
544
  self.vm
545
545
  .borrow_mut()
546
- .sys_state_get(key, Default::default())
546
+ .sys_state_get(key, None, Default::default())
547
547
  .map(Into::into)
548
548
  .map_err(core_error_to_magnus)
549
549
  }
@@ -551,7 +551,7 @@ impl RbVM {
551
551
  fn sys_get_state_keys(&self) -> Result<u32, Error> {
552
552
  self.vm
553
553
  .borrow_mut()
554
- .sys_state_get_keys()
554
+ .sys_state_get_keys(None)
555
555
  .map(Into::into)
556
556
  .map_err(core_error_to_magnus)
557
557
  }
@@ -560,21 +560,21 @@ impl RbVM {
560
560
  let bytes: Vec<u8> = unsafe { buffer.as_slice().to_vec() };
561
561
  self.vm
562
562
  .borrow_mut()
563
- .sys_state_set(key, bytes.into(), Default::default())
563
+ .sys_state_set(key, bytes.into(), None, Default::default())
564
564
  .map_err(core_error_to_magnus)
565
565
  }
566
566
 
567
567
  fn sys_clear_state(&self, key: String) -> Result<(), Error> {
568
568
  self.vm
569
569
  .borrow_mut()
570
- .sys_state_clear(key)
570
+ .sys_state_clear(key, None)
571
571
  .map_err(core_error_to_magnus)
572
572
  }
573
573
 
574
574
  fn sys_clear_all_state(&self) -> Result<(), Error> {
575
575
  self.vm
576
576
  .borrow_mut()
577
- .sys_state_clear_all()
577
+ .sys_state_clear_all(None)
578
578
  .map_err(core_error_to_magnus)
579
579
  }
580
580
 
@@ -750,7 +750,11 @@ impl RbVM {
750
750
  .map_err(core_error_to_magnus)
751
751
  }
752
752
 
753
- fn propose_run_completion_failure(&self, handle: u32, failure: &RbFailure) -> Result<(), Error> {
753
+ fn propose_run_completion_failure(
754
+ &self,
755
+ handle: u32,
756
+ failure: &RbFailure,
757
+ ) -> Result<(), Error> {
754
758
  self.vm
755
759
  .borrow_mut()
756
760
  .propose_run_completion(
@@ -863,16 +867,16 @@ impl RbVM {
863
867
  let bytes: Vec<u8> = unsafe { buffer.as_slice().to_vec() };
864
868
  self.vm
865
869
  .borrow_mut()
866
- .sys_complete_promise(key, NonEmptyValue::Success(bytes.into()), Default::default())
870
+ .sys_complete_promise(
871
+ key,
872
+ NonEmptyValue::Success(bytes.into()),
873
+ Default::default(),
874
+ )
867
875
  .map(Into::into)
868
876
  .map_err(core_error_to_magnus)
869
877
  }
870
878
 
871
- fn sys_complete_promise_failure(
872
- &self,
873
- key: String,
874
- failure: &RbFailure,
875
- ) -> Result<u32, Error> {
879
+ fn sys_complete_promise_failure(&self, key: String, failure: &RbFailure) -> Result<u32, Error> {
876
880
  self.vm
877
881
  .borrow_mut()
878
882
  .sys_complete_promise(
@@ -969,7 +973,7 @@ impl RbIdentityVerifier {
969
973
 
970
974
  // ── Error formatter ──
971
975
 
972
- use restate_sdk_shared_core::fmt::{set_error_formatter, ErrorFormatter};
976
+ use restate_sdk_shared_core::fmt::{ErrorFormatter, set_error_formatter};
973
977
 
974
978
  #[derive(Debug)]
975
979
  struct RubyErrorFormatter;
@@ -1032,7 +1036,10 @@ fn parse_unresolved_future(value: Value) -> Result<UnresolvedFuture, Error> {
1032
1036
  children.push(parse_unresolved_future(child)?);
1033
1037
  }
1034
1038
  let tag_name = tag.name().map_err(|_| {
1035
- Error::new(ruby.exception_arg_error(), "UnresolvedFuture tag is not a Symbol")
1039
+ Error::new(
1040
+ ruby.exception_arg_error(),
1041
+ "UnresolvedFuture tag is not a Symbol",
1042
+ )
1036
1043
  })?;
1037
1044
  match tag_name.as_ref() {
1038
1045
  "first_completed" => Ok(UnresolvedFuture::FirstCompleted(children)),
@@ -1107,13 +1114,25 @@ fn rb_exponential_retry_config_new(
1107
1114
  factor: Value,
1108
1115
  ) -> RbExponentialRetryConfig {
1109
1116
  let to_opt_u64 = |v: Value| -> Option<u64> {
1110
- if v.is_nil() { None } else { u64::try_convert(v).ok() }
1117
+ if v.is_nil() {
1118
+ None
1119
+ } else {
1120
+ u64::try_convert(v).ok()
1121
+ }
1111
1122
  };
1112
1123
  let to_opt_u32 = |v: Value| -> Option<u32> {
1113
- if v.is_nil() { None } else { u32::try_convert(v).ok() }
1124
+ if v.is_nil() {
1125
+ None
1126
+ } else {
1127
+ u32::try_convert(v).ok()
1128
+ }
1114
1129
  };
1115
1130
  let to_opt_f64 = |v: Value| -> Option<f64> {
1116
- if v.is_nil() { None } else { f64::try_convert(v).ok() }
1131
+ if v.is_nil() {
1132
+ None
1133
+ } else {
1134
+ f64::try_convert(v).ok()
1135
+ }
1117
1136
  };
1118
1137
  RbExponentialRetryConfig {
1119
1138
  initial_interval: to_opt_u64(initial_interval),
@@ -1186,13 +1205,23 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
1186
1205
 
1187
1206
  // ExponentialRetryConfig - constructor takes all 5 params (nil for unset)
1188
1207
  let erc_class = internal.define_class("ExponentialRetryConfig", ruby.class_object())?;
1189
- erc_class
1190
- .define_singleton_method("new", function!(rb_exponential_retry_config_new, 5))?;
1191
- erc_class
1192
- .define_method("initial_interval", method!(RbExponentialRetryConfig::initial_interval, 0))?;
1193
- erc_class.define_method("max_attempts", method!(RbExponentialRetryConfig::max_attempts, 0))?;
1194
- erc_class.define_method("max_duration", method!(RbExponentialRetryConfig::max_duration, 0))?;
1195
- erc_class.define_method("max_interval", method!(RbExponentialRetryConfig::max_interval, 0))?;
1208
+ erc_class.define_singleton_method("new", function!(rb_exponential_retry_config_new, 5))?;
1209
+ erc_class.define_method(
1210
+ "initial_interval",
1211
+ method!(RbExponentialRetryConfig::initial_interval, 0),
1212
+ )?;
1213
+ erc_class.define_method(
1214
+ "max_attempts",
1215
+ method!(RbExponentialRetryConfig::max_attempts, 0),
1216
+ )?;
1217
+ erc_class.define_method(
1218
+ "max_duration",
1219
+ method!(RbExponentialRetryConfig::max_duration, 0),
1220
+ )?;
1221
+ erc_class.define_method(
1222
+ "max_interval",
1223
+ method!(RbExponentialRetryConfig::max_interval, 0),
1224
+ )?;
1196
1225
  erc_class.define_method("factor", method!(RbExponentialRetryConfig::factor, 0))?;
1197
1226
 
1198
1227
  // Progress types
Binary file
Binary file
Binary file
@@ -1,7 +1,7 @@
1
1
  # typed: false
2
2
  # frozen_string_literal: true
3
3
 
4
- # rubocop:disable Style/EmptyMethod
4
+ # rubocop:disable-next Style/EmptyMethod
5
5
  module Restate
6
6
  # Signals when the current invocation attempt has finished — either the handler
7
7
  # completed, the connection was lost, or a transient error occurred.
@@ -264,4 +264,3 @@ module Restate
264
264
  def reject_promise(name, message, code: 500); end
265
265
  end
266
266
  end
267
- # rubocop:enable Style/EmptyMethod
@@ -2,5 +2,5 @@
2
2
  # frozen_string_literal: true
3
3
 
4
4
  module Restate
5
- VERSION = '1.2.1'
5
+ VERSION = '1.3.1'
6
6
  end
data/lib/restate/vm.rb CHANGED
@@ -3,7 +3,7 @@
3
3
 
4
4
  begin
5
5
  # Cross-compiled native gems place the binary in a version-specific directory
6
- # e.g., lib/restate/3.3/restate_internal.bundle
6
+ # e.g., lib/restate/4.0/restate_internal.bundle
7
7
  RUBY_VERSION =~ /(\d+\.\d+)/
8
8
  require_relative "#{Regexp.last_match(1)}/restate_internal"
9
9
  rescue LoadError
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: restate-sdk
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.2.1
4
+ version: 1.3.1
5
5
  platform: aarch64-linux
6
6
  authors:
7
7
  - Restate Developers
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2026-08-14 00:00:00.000000000 Z
11
+ date: 2026-11-19 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: async
@@ -24,6 +24,34 @@ dependencies:
24
24
  - - "~>"
25
25
  - !ruby/object:Gem::Version
26
26
  version: '2.0'
27
+ - !ruby/object:Gem::Dependency
28
+ name: base64
29
+ requirement: !ruby/object:Gem::Requirement
30
+ requirements:
31
+ - - ">="
32
+ - !ruby/object:Gem::Version
33
+ version: '0'
34
+ type: :runtime
35
+ prerelease: false
36
+ version_requirements: !ruby/object:Gem::Requirement
37
+ requirements:
38
+ - - ">="
39
+ - !ruby/object:Gem::Version
40
+ version: '0'
41
+ - !ruby/object:Gem::Dependency
42
+ name: logger
43
+ requirement: !ruby/object:Gem::Requirement
44
+ requirements:
45
+ - - ">="
46
+ - !ruby/object:Gem::Version
47
+ version: '0'
48
+ type: :runtime
49
+ prerelease: false
50
+ version_requirements: !ruby/object:Gem::Requirement
51
+ requirements:
52
+ - - ">="
53
+ - !ruby/object:Gem::Version
54
+ version: '0'
27
55
  - !ruby/object:Gem::Dependency
28
56
  name: rack
29
57
  requirement: !ruby/object:Gem::Requirement