@temporalio/core-bridge 0.17.2 → 0.18.0

package/sdk-core/{test_utils → core-api}/Cargo.toml

@@ -1,20 +1,23 @@
 [package]
-name = "test_utils"
+name = "temporal-sdk-core-api"
 version = "0.1.0"
-authors = ["Spencer Judge <spencer@temporal.io>"]
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+anyhow = "1.0"
 async-trait = "0.1"
-base64 = "0.13"
-futures = "0.3"
+derive_builder = "0.10"
 log = "0.4"
-rand = "0.8"
-temporal-sdk-core = { path = ".." }
-url = "2.2"
+prost-types = "0.9"
+thiserror = "1.0"
+tonic = "0.6"
 
 [dependencies.temporal-sdk-core-protos]
 path = "../sdk-core-protos"
 version = "0.1"
+
+[dependencies.temporal-client]
+path = "../client"
+version = "0.1"

package/sdk-core/{src → core-api/src}/errors.rs

@@ -1,45 +1,19 @@
 //! Error types exposed by public APIs
 
-use crate::{machines::WFMachinesError, WorkerLookupErr};
+use prost_types::TimestampOutOfSystemRangeError;
+use temporal_client::GatewayInitError;
 use temporal_sdk_core_protos::coresdk::{
-    activity_result::ActivityResult, workflow_completion::WfActivationCompletion,
+    activity_result::ActivityExecutionResult,
+    workflow_activation::remove_from_cache::EvictionReason,
+    workflow_completion::WorkflowActivationCompletion,
 };
-use tonic::codegen::http::uri::InvalidUri;
-
-#[derive(Debug)]
-pub(crate) struct WorkflowUpdateError {
-    /// Underlying workflow error
-    pub source: WFMachinesError,
-    /// The run id of the erring workflow
-    #[allow(dead_code)] // Useful in debug output
-    pub run_id: String,
-}
-
-impl From<WorkflowMissingError> for WorkflowUpdateError {
-    fn from(wme: WorkflowMissingError) -> Self {
-        Self {
-            source: WFMachinesError::Fatal("Workflow machines missing".to_string()),
-            run_id: wme.run_id,
-        }
-    }
-}
-
-/// The workflow machines were expected to be in the cache but were not
-#[derive(Debug)]
-pub(crate) struct WorkflowMissingError {
-    /// The run id of the erring workflow
-    pub run_id: String,
-}
 
 /// Errors thrown during initialization of [crate::Core]
 #[derive(thiserror::Error, Debug)]
 pub enum CoreInitError {
-    /// Invalid URI. Configuration error, fatal.
-    #[error("Invalid URI: {0:?}")]
-    InvalidUri(#[from] InvalidUri),
     /// Server connection error. Crashing and restarting the worker is likely best.
     #[error("Server connection error: {0:?}")]
-    TonicTransportError(#[from] tonic::transport::Error),
+    GatewayInitError(#[from] GatewayInitError),
     /// There was a problem initializing telemetry
     #[error("Telemetry initialization error: {0:?}")]
     TelemetryInitError(anyhow::Error),
@@ -67,15 +41,6 @@ pub enum PollWfError {
     NoWorkerForQueue(String),
 }
 
-impl From<WorkerLookupErr> for PollWfError {
-    fn from(e: WorkerLookupErr) -> Self {
-        match e {
-            WorkerLookupErr::Shutdown(_) => Self::ShutDown,
-            WorkerLookupErr::NoWorker(s) => Self::NoWorkerForQueue(s),
-        }
-    }
-}
-
 /// Errors thrown by [crate::Core::poll_activity_task]
 #[derive(thiserror::Error, Debug)]
 pub enum PollActivityError {
@@ -92,15 +57,6 @@ pub enum PollActivityError {
     NoWorkerForQueue(String),
 }
 
-impl From<WorkerLookupErr> for PollActivityError {
-    fn from(e: WorkerLookupErr) -> Self {
-        match e {
-            WorkerLookupErr::Shutdown(_) => Self::ShutDown,
-            WorkerLookupErr::NoWorker(s) => Self::NoWorkerForQueue(s),
-        }
-    }
-}
-
 /// Errors thrown by [crate::Core::complete_workflow_activation]
 #[derive(thiserror::Error, Debug)]
 #[allow(clippy::large_enum_variant)]
@@ -111,7 +67,7 @@ pub enum CompleteWfError {
         /// Reason the completion was malformed
         reason: String,
         /// The completion, which may not be included to avoid unnecessary copies.
-        completion: Option<WfActivationCompletion>,
+        completion: Option<WorkflowActivationCompletion>,
     },
     /// There is no worker registered for the queue being polled
     #[error("No worker registered for queue: {0}")]
@@ -122,16 +78,6 @@ pub enum CompleteWfError {
     TonicError(#[from] tonic::Status),
 }
 
-impl From<WorkerLookupErr> for CompleteWfError {
-    fn from(e: WorkerLookupErr) -> Self {
-        match e {
-            WorkerLookupErr::Shutdown(s) | WorkerLookupErr::NoWorker(s) => {
-                Self::NoWorkerForQueue(s)
-            }
-        }
-    }
-}
-
 /// Errors thrown by [crate::Core::complete_activity_task]
 #[derive(thiserror::Error, Debug)]
 pub enum CompleteActivityError {
@@ -141,7 +87,7 @@ pub enum CompleteActivityError {
         /// Reason the completion was malformed
         reason: String,
         /// The completion, which may not be included to avoid unnecessary copies.
-        completion: Option<ActivityResult>,
+        completion: Option<ActivityExecutionResult>,
     },
     /// Unhandled error when calling the temporal server. Core will attempt to retry any non-fatal
     /// errors, so lang should consider this fatal.
@@ -152,34 +98,6 @@ pub enum CompleteActivityError {
     NoWorkerForQueue(String),
 }
 
-impl From<WorkerLookupErr> for CompleteActivityError {
-    fn from(e: WorkerLookupErr) -> Self {
-        match e {
-            WorkerLookupErr::Shutdown(s) | WorkerLookupErr::NoWorker(s) => {
-                Self::NoWorkerForQueue(s)
-            }
-        }
-    }
-}
-
-/// Errors thrown by [crate::Core::record_activity_heartbeat]
-#[derive(thiserror::Error, Debug)]
-pub enum ActivityHeartbeatError {
-    /// Heartbeat referenced an activity that we don't think exists. It may have completed already.
-    #[error("Heartbeat has been sent for activity that either completed or never started on this worker.")]
-    UnknownActivity,
-    /// There was no heartbeat timeout set for the activity, but one is required to heartbeat.
-    #[error("Heartbeat is only allowed on activities with heartbeat timeout.")]
-    HeartbeatTimeoutNotSet,
-    /// There was a set heartbeat timeout, but it was not parseable. A valid timeout is requried
-    /// to heartbeat.
-    #[error("Unable to parse activity heartbeat timeout.")]
-    InvalidHeartbeatTimeout,
-    /// Core is shutting down and thus new heartbeats are not accepted
-    #[error("New heartbeat requests are not accepted while shutting down")]
-    ShuttingDown,
-}
-
 /// Errors thrown by [crate::Core::register_worker]
 #[derive(thiserror::Error, Debug)]
 pub enum WorkerRegistrationError {
@@ -187,3 +105,37 @@ pub enum WorkerRegistrationError {
     #[error("Worker already registered for queue: {0}")]
     WorkerAlreadyRegisteredForQueue(String),
 }
+
+/// Errors thrown inside of workflow machines
+#[derive(thiserror::Error, Debug)]
+pub enum WFMachinesError {
+    #[error("Nondeterminism error: {0}")]
+    Nondeterminism(String),
+    #[error("Fatal error in workflow machines: {0}")]
+    Fatal(String),
+
+    #[error("Unrecoverable network error while fetching history: {0}")]
+    HistoryFetchingError(tonic::Status),
+
+    /// Should always be caught internally and turned into a workflow task failure
+    #[error("Unable to process partial event history because workflow is no longer cached.")]
+    CacheMiss,
+}
+
+impl WFMachinesError {
+    pub fn evict_reason(&self) -> EvictionReason {
+        match self {
+            WFMachinesError::Nondeterminism(_) => EvictionReason::Nondeterminism,
+            WFMachinesError::Fatal(_) | WFMachinesError::HistoryFetchingError(_) => {
+                EvictionReason::Fatal
+            }
+            WFMachinesError::CacheMiss => EvictionReason::CacheMiss,
+        }
+    }
+}
+
+impl From<TimestampOutOfSystemRangeError> for WFMachinesError {
+    fn from(_: TimestampOutOfSystemRangeError) -> Self {
+        Self::Fatal("Could not decode timestamp".to_string())
+    }
+}

package/sdk-core/core-api/src/lib.rs

@@ -0,0 +1,158 @@
+pub mod errors;
+pub mod worker;
+
+use crate::{
+    errors::{
+        CompleteActivityError, CompleteWfError, PollActivityError, PollWfError,
+        WorkerRegistrationError,
+    },
+    worker::WorkerConfig,
+};
+use log::Level;
+use std::{
+    sync::Arc,
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+use temporal_client::ServerGatewayApis;
+use temporal_sdk_core_protos::coresdk::{
+    activity_task::ActivityTask, workflow_activation::WorkflowActivation,
+    workflow_completion::WorkflowActivationCompletion, ActivityHeartbeat, ActivityTaskCompletion,
+};
+
+/// This trait is the primary way by which language specific SDKs interact with the core SDK. It is
+/// expected that only one instance of an implementation will exist for the lifetime of the
+/// worker(s) using it.
+#[async_trait::async_trait]
+pub trait Core: Send + Sync {
+    /// Register a worker with core. Workers poll on a specific task queue, and when calling core's
+    /// poll functions, you must provide a task queue name. If there was already a worker registered
+    /// with the same task queue name, it will be shut down and a new one will be created.
+    fn register_worker(&self, config: WorkerConfig) -> Result<(), WorkerRegistrationError>;
+
+    /// Ask the core for some work, returning a [WorkflowActivation]. It is then the language SDK's
+    /// responsibility to call the appropriate workflow code with the provided inputs. Blocks
+    /// indefinitely until such work is available or [Core::shutdown] is called.
+    ///
+    /// The returned activation is guaranteed to be for the same task queue / worker which was
+    /// provided as the `task_queue` argument.
+    ///
+    /// It is important to understand that all activations must be responded to. There can only
+    /// be one outstanding activation for a particular run of a workflow at any time. If an
+    /// activation is not responded to, it will cause that workflow to become stuck forever.
+    ///
+    /// Activations that contain only a `remove_from_cache` job should not cause the workflow code
+    /// to be invoked and may be responded to with an empty command list. Eviction jobs may also
+    /// appear with other jobs, but will always appear last in the job list. In this case it is
+    /// expected that the workflow code will be invoked, and the response produced as normal, but
+    /// the caller should evict the run after doing so.
+    ///
+    /// It is rarely a good idea to call poll concurrently. It handles polling the server
+    /// concurrently internally.
+    ///
+    /// TODO: Examples
+    async fn poll_workflow_activation(
+        &self,
+        task_queue: &str,
+    ) -> Result<WorkflowActivation, PollWfError>;
+
+    /// Ask the core for some work, returning an [ActivityTask]. It is then the language SDK's
+    /// responsibility to call the appropriate activity code with the provided inputs. Blocks
+    /// indefinitely until such work is available or [Core::shutdown] is called.
+    ///
+    /// The returned activation is guaranteed to be for the same task queue / worker which was
+    /// provided as the `task_queue` argument.
+    ///
+    /// It is rarely a good idea to call poll concurrently. It handles polling the server
+    /// concurrently internally.
+    ///
+    /// TODO: Examples
+    async fn poll_activity_task(&self, task_queue: &str)
+        -> Result<ActivityTask, PollActivityError>;
+
+    /// Tell the core that a workflow activation has completed. May be freely called concurrently.
+    async fn complete_workflow_activation(
+        &self,
+        completion: WorkflowActivationCompletion,
+    ) -> Result<(), CompleteWfError>;
+
+    /// Tell the core that an activity has finished executing. May be freely called concurrently.
+    async fn complete_activity_task(
+        &self,
+        completion: ActivityTaskCompletion,
+    ) -> Result<(), CompleteActivityError>;
+
+    /// Notify workflow that an activity is still alive. Long running activities that take longer
+    /// than `activity_heartbeat_timeout` to finish must call this function in order to report
+    /// progress, otherwise the activity will timeout and a new attempt will be scheduled.
+    ///
+    /// The first heartbeat request will be sent immediately, subsequent rapid calls to this
+    /// function will result in heartbeat requests being aggregated and the last one received during
+    /// the aggregation period will be sent to the server, where that period is defined as half the
+    /// heartbeat timeout.
+    ///
+    /// Unlike java/go SDKs we do not return cancellation status as part of heartbeat response and
+    /// instead send it as a separate activity task to the lang, decoupling heartbeat and
+    /// cancellation processing.
+    ///
+    /// For now activity still need to send heartbeats if they want to receive cancellation
+    /// requests. In the future we will change this and will dispatch cancellations more
+    /// proactively. Note that this function does not block on the server call and returns
+    /// immediately. Underlying validation errors are swallowed and logged, this has been agreed to
+    /// be optimal behavior for the user as we don't want to break activity execution due to badly
+    /// configured heartbeat options.
+    fn record_activity_heartbeat(&self, details: ActivityHeartbeat);
+
+    /// Request that a workflow be evicted by its run id. This will generate a workflow activation
+    /// with the eviction job inside it to be eventually returned by
+    /// [Core::poll_workflow_activation]. If the workflow had any existing outstanding activations,
+    /// such activations are invalidated and subsequent completions of them will do nothing and log
+    /// a warning.
+    fn request_workflow_eviction(&self, task_queue: &str, run_id: &str);
+
+    /// Returns core's instance of the [ServerGatewayApis] implementor it is using.
+    fn server_gateway(&self) -> Arc<dyn ServerGatewayApis + Send + Sync>;
+
+    /// Initiates async shutdown procedure, eventually ceases all polling of the server and shuts
+    /// down all registered workers. [Core::poll_workflow_activation] should be called until it
+    /// returns [PollWfError::ShutDown] to ensure that any workflows which are still undergoing
+    /// replay have an opportunity to finish. This means that the lang sdk will need to call
+    /// [Core::complete_workflow_activation] for those workflows until they are done. At that point,
+    /// the lang SDK can end the process, or drop the [Core] instance, which will close the
+    /// connection.
+    async fn shutdown(&self);
+
+    /// Shut down a specific worker. Will cease all polling on the task queue and future attempts
+    /// to poll that queue will return [PollWfError::NoWorkerForQueue].
+    async fn shutdown_worker(&self, task_queue: &str);
+
+    /// Core buffers logs that should be shuttled over to lang so that they may be rendered with
+    /// the user's desired logging library. Use this function to grab the most recent buffered logs
+    /// since the last time it was called. A fixed number of such logs are retained at maximum, with
+    /// the oldest being dropped when full.
+    ///
+    /// Returns the list of logs from oldest to newest. Returns an empty vec if the feature is not
+    /// configured.
+    fn fetch_buffered_logs(&self) -> Vec<CoreLog>;
+}
+
+/// A log line (which ultimately came from a tracing event) exported from Core->Lang
+#[derive(Debug)]
+pub struct CoreLog {
+    /// Log message
+    pub message: String,
+    /// Time log was generated (not when it was exported to lang)
+    pub timestamp: SystemTime,
+    /// Message level
+    pub level: Level,
+    // KV pairs aren't meaningfully exposed yet to the log interface by tracing
+}
+
+impl CoreLog {
+    /// Return timestamp as ms since epoch
+    pub fn millis_since_epoch(&self) -> u128 {
+        self.timestamp
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or(Duration::ZERO)
+            .as_millis()
+    }
+}

package/sdk-core/{src/worker/config.rs → core-api/src/worker.rs}

@@ -1,11 +1,9 @@
 use std::time::Duration;
 
-#[cfg(test)]
-use crate::test_help::TEST_Q;
-
 /// Defines per-worker configuration options
 #[derive(Debug, Clone, derive_builder::Builder)]
 #[builder(setter(into), build_fn(validate = "Self::validate"))]
+#[non_exhaustive]
 // TODO: per-second queue limits
 pub struct WorkerConfig {
     /// What task queue will this worker poll from? This task queue name will be used for both
@@ -23,10 +21,13 @@ pub struct WorkerConfig {
     /// "outstanding" until all activations it requires have been completed.
     #[builder(default = "100")]
     pub max_outstanding_workflow_tasks: usize,
-    /// The maximum allowed number of activity tasks that will ever be given to this worker at one
-    /// time.
+    /// The maximum number of activity tasks that will ever be given to this worker concurrently
     #[builder(default = "100")]
     pub max_outstanding_activities: usize,
+    /// The maximum number of local activity tasks that will ever be given to this worker
+    /// concurrently
+    #[builder(default = "100")]
+    pub max_outstanding_local_activities: usize,
     /// Maximum number of concurrent poll workflow task requests we will perform at a time on this
     /// worker's task queue. See also [WorkerConfig::nonsticky_to_sticky_poll_ratio]. Must be at
     /// least 1.
@@ -64,6 +65,18 @@ pub struct WorkerConfig {
     pub default_heartbeat_throttle_interval: Duration,
 }
 
+impl WorkerConfig {
+    pub fn max_nonsticky_polls(&self) -> usize {
+        ((self.max_concurrent_wft_polls as f32 * self.nonsticky_to_sticky_poll_ratio) as usize)
+            .max(1)
+    }
+    pub fn max_sticky_polls(&self) -> usize {
+        self.max_concurrent_wft_polls
+            .saturating_sub(self.max_nonsticky_polls())
+            .max(1)
+    }
+}
+
 impl WorkerConfigBuilder {
     fn validate(&self) -> Result<(), String> {
         if self.max_concurrent_wft_polls == Some(0) {
@@ -72,21 +85,3 @@ impl WorkerConfigBuilder {
         Ok(())
     }
 }
-
-impl WorkerConfig {
-    #[cfg(test)]
-    pub fn default_test_q() -> Self {
-        WorkerConfigBuilder::default()
-            .task_queue(TEST_Q)
-            .build()
-            .unwrap()
-    }
-
-    #[cfg(test)]
-    pub fn default(queue: &str) -> Self {
-        WorkerConfigBuilder::default()
-            .task_queue(queue)
-            .build()
-            .unwrap()
-    }
-}

package/sdk-core/etc/deps.svg

@@ -0,0 +1,156 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+ "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Generated by graphviz version 2.50.0 (0)
+ -->
+<!-- Pages: 1 -->
+<svg width="421pt" height="404pt"
+ viewBox="0.00 0.00 420.50 404.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 400)">
+<polygon fill="white" stroke="transparent" points="-4,4 -4,-400 416.5,-400 416.5,4 -4,4"/>
+<!-- 0 -->
+<g id="node1" class="node">
+<title>0</title>
+<polygon fill="none" stroke="black" points="248,-396 132,-396 132,-360 248,-360 248,-396"/>
+<text text-anchor="middle" x="190" y="-374.3" font-family="Times,serif" font-size="14.00">temporal&#45;sdk&#45;core</text>
+</g>
+<!-- 1 -->
+<g id="node2" class="node">
+<title>1</title>
+<polygon fill="none" stroke="black" points="58,-324 0,-324 0,-288 58,-288 58,-324"/>
+<text text-anchor="middle" x="29" y="-302.3" font-family="Times,serif" font-size="14.00">rustfsm</text>
+</g>
+<!-- 0&#45;&gt;1 -->
+<g id="edge1" class="edge">
+<title>0&#45;&gt;1</title>
+<path fill="none" stroke="black" d="M150.61,-359.88C125.27,-348.86 92.5,-334.61 67.36,-323.68"/>
+<polygon fill="black" stroke="black" points="68.7,-320.44 58.13,-319.67 65.91,-326.86 68.7,-320.44"/>
+</g>
+<!-- 4 -->
+<g id="node3" class="node">
+<title>4</title>
+<polygon fill="none" stroke="black" points="214,-108 114,-108 114,-72 214,-72 214,-108"/>
+<text text-anchor="middle" x="164" y="-86.3" font-family="Times,serif" font-size="14.00">temporal&#45;client</text>
+</g>
+<!-- 0&#45;&gt;4 -->
+<g id="edge2" class="edge">
+<title>0&#45;&gt;4</title>
+<path fill="none" stroke="black" d="M181.7,-359.96C171.44,-325.92 157.74,-247.02 153,-180 151.87,-164.04 152.7,-160 153,-144 153.16,-135.58 153.46,-126.42 154.19,-118.12"/>
+<polygon fill="black" stroke="black" points="157.67,-118.52 155.37,-108.18 150.71,-117.7 157.67,-118.52"/>
+</g>
+<!-- 0&#45;&gt;4 -->
+<g id="edge3" class="edge">
+<title>0&#45;&gt;4</title>
+<path fill="none" stroke="blue" d="M191.8,-359.96C189.44,-325.92 175.74,-247.02 171,-180 169.87,-164.04 170.7,-160 171,-144 171.16,-135.68 171.45,-126.63 171.37,-118.4"/>
+<polygon fill="blue" stroke="blue" points="174.86,-118.05 171.01,-108.18 167.87,-118.3 174.86,-118.05"/>
+</g>
+<!-- 5 -->
+<g id="node4" class="node">
+<title>5</title>
+<polygon fill="none" stroke="black" points="319.5,-36 164.5,-36 164.5,0 319.5,0 319.5,-36"/>
+<text text-anchor="middle" x="242" y="-14.3" font-family="Times,serif" font-size="14.00">temporal&#45;sdk&#45;core&#45;protos</text>
+</g>
+<!-- 0&#45;&gt;5 -->
+<g id="edge6" class="edge">
+<title>0&#45;&gt;5</title>
+<path fill="none" stroke="black" d="M165.88,-359.82C135.16,-335.73 86,-288.78 86,-235 86,-235 86,-235 86,-161 86,-120.55 78.76,-102.78 105,-72 118.09,-56.64 136.18,-45.72 154.93,-37.95"/>
+<polygon fill="black" stroke="black" points="156.39,-41.14 164.46,-34.27 153.87,-34.6 156.39,-41.14"/>
+</g>
+<!-- 6 -->
+<g id="node5" class="node">
+<title>6</title>
+<polygon fill="none" stroke="black" points="307.5,-180 170.5,-180 170.5,-144 307.5,-144 307.5,-180"/>
+<text text-anchor="middle" x="239" y="-158.3" font-family="Times,serif" font-size="14.00">temporal&#45;sdk&#45;core&#45;api</text>
+</g>
+<!-- 0&#45;&gt;6 -->
+<g id="edge5" class="edge">
+<title>0&#45;&gt;6</title>
+<path fill="none" stroke="black" d="M193.8,-359.93C197.8,-342.01 204.29,-313.01 210,-288 217.68,-254.36 226.68,-215.68 232.6,-190.36"/>
+<polygon fill="black" stroke="black" points="236.06,-190.92 234.93,-180.38 229.24,-189.32 236.06,-190.92"/>
+</g>
+<!-- 7 -->
+<g id="node6" class="node">
+<title>7</title>
+<polygon fill="none" stroke="black" points="412.5,-252 323.5,-252 323.5,-216 412.5,-216 412.5,-252"/>
+<text text-anchor="middle" x="368" y="-230.3" font-family="Times,serif" font-size="14.00">temporal&#45;sdk</text>
+</g>
+<!-- 0&#45;&gt;7 -->
+<g id="edge4" class="edge">
+<title>0&#45;&gt;7</title>
+<path fill="none" stroke="blue" d="M224.19,-359.83C242.9,-350.78 265.76,-338.54 284,-324 307.09,-305.6 328.26,-279.21 343.85,-259.94"/>
+<polygon fill="blue" stroke="blue" points="346.58,-262.13 350.18,-252.17 341.15,-257.71 346.58,-262.13"/>
+</g>
+<!-- 8 -->
+<g id="node7" class="node">
+<title>8</title>
+<polygon fill="none" stroke="black" points="283.5,-324 218.5,-324 218.5,-288 283.5,-288 283.5,-324"/>
+<text text-anchor="middle" x="251" y="-302.3" font-family="Times,serif" font-size="14.00">test_utils</text>
+</g>
+<!-- 0&#45;&gt;8 -->
+<g id="edge7" class="edge">
+<title>0&#45;&gt;8</title>
+<path fill="none" stroke="blue" d="M199.16,-359.7C205.68,-351.22 214.51,-340.86 223.1,-331.58"/>
+<polygon fill="blue" stroke="blue" points="225.85,-333.77 230.2,-324.1 220.78,-328.95 225.85,-333.77"/>
+</g>
+<!-- 4&#45;&gt;5 -->
+<g id="edge8" class="edge">
+<title>4&#45;&gt;5</title>
+<path fill="none" stroke="black" d="M183.28,-71.7C192.92,-63.05 204.73,-52.45 215.23,-43.03"/>
+<polygon fill="black" stroke="black" points="217.84,-45.39 222.94,-36.1 213.16,-40.18 217.84,-45.39"/>
+</g>
+<!-- 6&#45;&gt;4 -->
+<g id="edge9" class="edge">
+<title>6&#45;&gt;4</title>
+<path fill="none" stroke="black" d="M220.46,-143.7C211.2,-135.05 199.84,-124.45 189.74,-115.03"/>
+<polygon fill="black" stroke="black" points="192.02,-112.37 182.33,-108.1 187.25,-117.49 192.02,-112.37"/>
+</g>
+<!-- 6&#45;&gt;5 -->
+<g id="edge10" class="edge">
+<title>6&#45;&gt;5</title>
+<path fill="none" stroke="black" d="M239.36,-143.87C239.87,-119.67 240.81,-75.21 241.42,-46.39"/>
+<polygon fill="black" stroke="black" points="244.92,-46.26 241.64,-36.19 237.93,-46.11 244.92,-46.26"/>
+</g>
+<!-- 7&#45;&gt;0 -->
+<g id="edge11" class="edge">
+<title>7&#45;&gt;0</title>
+<path fill="none" stroke="black" d="M363.18,-252.17C352.26,-271.5 328.39,-302.97 302,-324 286.4,-336.43 267.42,-347.19 249.5,-355.7"/>
+<polygon fill="black" stroke="black" points="247.88,-352.6 240.25,-359.95 250.8,-358.96 247.88,-352.6"/>
+</g>
+<!-- 7&#45;&gt;5 -->
+<g id="edge13" class="edge">
+<title>7&#45;&gt;5</title>
+<path fill="none" stroke="black" d="M371.05,-215.88C375.69,-184.29 380.99,-116.06 350,-72 340.45,-58.42 326.41,-48.16 311.6,-40.47"/>
+<polygon fill="black" stroke="black" points="312.84,-37.19 302.31,-36.01 309.81,-43.5 312.84,-37.19"/>
+</g>
+<!-- 7&#45;&gt;6 -->
+<g id="edge12" class="edge">
+<title>7&#45;&gt;6</title>
+<path fill="none" stroke="black" d="M336.44,-215.88C319.34,-206.6 298.02,-195.03 279.68,-185.08"/>
+<polygon fill="black" stroke="black" points="281.14,-181.88 270.68,-180.19 277.8,-188.04 281.14,-181.88"/>
+</g>
+<!-- 8&#45;&gt;0 -->
+<g id="edge15" class="edge">
+<title>8&#45;&gt;0</title>
+<path fill="none" stroke="black" d="M241.99,-324.1C235.51,-332.55 226.69,-342.9 218.1,-352.2"/>
+<polygon fill="black" stroke="black" points="215.33,-350.03 210.99,-359.7 220.41,-354.85 215.33,-350.03"/>
+</g>
+<!-- 8&#45;&gt;5 -->
+<g id="edge17" class="edge">
+<title>8&#45;&gt;5</title>
+<path fill="none" stroke="black" d="M266.47,-287.62C290.36,-258.6 332,-198.15 317,-144 306.53,-106.2 281.25,-68.36 262.93,-44.38"/>
+<polygon fill="black" stroke="black" points="265.45,-41.92 256.54,-36.2 259.94,-46.23 265.45,-41.92"/>
+</g>
+<!-- 8&#45;&gt;6 -->
+<g id="edge16" class="edge">
+<title>8&#45;&gt;6</title>
+<path fill="none" stroke="black" d="M249.55,-287.87C247.51,-263.67 243.75,-219.21 241.31,-190.39"/>
+<polygon fill="black" stroke="black" points="244.78,-189.86 240.45,-180.19 237.81,-190.45 244.78,-189.86"/>
+</g>
+<!-- 8&#45;&gt;7 -->
+<g id="edge14" class="edge">
+<title>8&#45;&gt;7</title>
+<path fill="none" stroke="black" d="M279.62,-287.88C294.92,-278.72 313.94,-267.34 330.42,-257.48"/>
+<polygon fill="black" stroke="black" points="332.48,-260.33 339.27,-252.19 328.89,-254.32 332.48,-260.33"/>
+</g>
+</g>
+</svg>

package/sdk-core/fsm/rustfsm_procmacro/src/lib.rs

@@ -126,19 +126,19 @@ use syn::{
 /// either case the function is expected to return a `TransitionResult` to the appropriate state.
 ///
 /// The first transition can be interpreted as "If the machine is in the locked state, when a
-/// `CardReadable` event is seen, call `on_card_readable` (pasing in `CardData`) and transition to
+/// `CardReadable` event is seen, call `on_card_readable` (passing in `CardData`) and transition to
 /// the `ReadingCard` state.
 ///
 /// The macro will generate a few things:
 /// * A struct for the overall state machine, named with the provided name. Here:
-///   ```ignore
+///   ```text
 ///   struct CardMachine {
 ///       state: CardMachineState,
 ///       shared_state: CardId,
 ///   }
 ///   ```
 /// * An enum with a variant for each state, named with the provided name + "State".
-///   ```ignore
+///   ```text
 ///   enum CardMachineState {
 ///       Locked(Locked),
 ///       ReadingCard(ReadingCard),
@@ -153,7 +153,7 @@ use syn::{
 ///   generated. This enum must be used as the destination "state" from those handlers.
 /// * An enum with a variant for each event. You are expected to define the type (if any) contained
 ///   in the event variant.
-///   ```ignore
+///   ```text
 ///   enum CardMachineEvents {
 ///     CardReadable(CardData)
 ///   }
@@ -565,7 +565,7 @@ impl StateMachineDefinition {
                     &self.shared_state
                 }
 
-                fn on_final_state(&self) -> bool {
+                fn has_reached_final_state(&self) -> bool {
                     self.state.is_final()
                 }
 

package/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/no_handle_conversions_require_into_fail.stderr

@@ -5,10 +5,8 @@ error[E0277]: the trait bound `One: From<Two>` is not satisfied
     |                  ^^^ the trait `From<Two>` is not implemented for `One`
     |
     = note: required because of the requirements on the impl of `Into<One>` for `Two`
-note: required by `TransitionResult::<Sm, Ds>::from`
+note: required by a bound in `TransitionResult::<Sm, Ds>::from`
    --> $WORKSPACE/fsm/rustfsm_trait/src/lib.rs
     |
-    | /     pub fn from<CurrentState>(current_state: CurrentState) -> Self
-    | |     where
-    | |         CurrentState: Into<Ds>,
-    | |_______________________________^
+    |         CurrentState: Into<Ds>,
+    |                       ^^^^^^^^ required by this bound in `TransitionResult::<Sm, Ds>::from`