temporalio 0.0.0 → 0.0.1

data/bridge/sdk-core/core-api/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "temporal-sdk-core-api"
+version = "0.1.0"
+edition = "2021"
+authors = ["Spencer Judge <spencer@temporal.io>"]
+license-file = "LICENSE.txt"
+description = "Interface definitions for the Temporal Core SDK"
+homepage = "https://temporal.io/"
+repository = "https://github.com/temporalio/sdk-core"
+keywords = ["temporal", "workflow"]
+categories = ["development-tools"]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0"
+async-trait = "0.1"
+derive_builder = "0.11"
+log = "0.4"
+opentelemetry = "0.18"
+prost-types = "0.11"
+thiserror = "1.0"
+tonic = "0.8"
+
+[dependencies.temporal-sdk-core-protos]
+path = "../sdk-core-protos"
+version = "0.1"
+
+[dependencies.temporal-client]
+path = "../client"
+version = "0.1"

data/bridge/sdk-core/core-api/LICENSE.txt

@@ -0,0 +1,23 @@
+Temporal Core SDK
+
+The MIT License
+
+Copyright (c) 2021 Temporal Technologies, Inc. All Rights Reserved
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/bridge/sdk-core/core-api/src/errors.rs

@@ -0,0 +1,95 @@
+//! Error types exposed by public APIs
+
+use prost_types::TimestampError;
+use temporal_sdk_core_protos::coresdk::{
+    activity_result::ActivityExecutionResult,
+    workflow_activation::remove_from_cache::EvictionReason,
+};
+
+/// Errors thrown by [crate::Worker::poll_workflow_activation]
+#[derive(thiserror::Error, Debug)]
+pub enum PollWfError {
+    /// [crate::Worker::shutdown] was called, and there are no more replay tasks to be handled. Lang
+    /// must call [crate::Worker::complete_workflow_activation] for any remaining tasks, and then may
+    /// exit.
+    #[error("Core is shut down and there are no more workflow replay tasks")]
+    ShutDown,
+    /// Unhandled error when calling the temporal server. Core will attempt to retry any non-fatal
+    /// errors, so lang should consider this fatal.
+    #[error("Unhandled grpc error when workflow polling: {0:?}")]
+    TonicError(#[from] tonic::Status),
+    /// Unhandled error when completing a workflow during a poll -- this can happen when there is no
+    /// work for lang to perform, but the server sent us a workflow task (EX: An activity completed
+    /// even though we already cancelled it)
+    #[error("Unhandled error when auto-completing workflow task: {0:?}")]
+    AutocompleteError(#[from] CompleteWfError),
+}
+
+/// Errors thrown by [crate::Worker::poll_activity_task]
+#[derive(thiserror::Error, Debug)]
+pub enum PollActivityError {
+    /// [crate::Worker::shutdown] was called, we will no longer fetch new activity tasks. Lang must
+    /// ensure it is finished with any workflow replay, see [PollWfError::ShutDown]
+    #[error("Core is shut down")]
+    ShutDown,
+    /// Unhandled error when calling the temporal server. Core will attempt to retry any non-fatal
+    /// errors, so lang should consider this fatal.
+    #[error("Unhandled grpc error when activity polling: {0:?}")]
+    TonicError(#[from] tonic::Status),
+}
+
+/// Errors thrown by [crate::Worker::complete_workflow_activation]
+#[derive(thiserror::Error, Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum CompleteWfError {
+    /// Lang SDK sent us a malformed workflow completion. This likely means a bug in the lang sdk.
+    #[error("Lang SDK sent us a malformed workflow completion for run ({run_id}): {reason}")]
+    MalformedWorkflowCompletion {
+        /// Reason the completion was malformed
+        reason: String,
+        /// The run associated with the completion
+        run_id: String,
+    },
+}
+
+/// Errors thrown by [crate::Worker::complete_activity_task]
+#[derive(thiserror::Error, Debug)]
+pub enum CompleteActivityError {
+    /// Lang SDK sent us a malformed activity completion. This likely means a bug in the lang sdk.
+    #[error("Lang SDK sent us a malformed activity completion ({reason}): {completion:?}")]
+    MalformedActivityCompletion {
+        /// Reason the completion was malformed
+        reason: String,
+        /// The completion, which may not be included to avoid unnecessary copies.
+        completion: Option<ActivityExecutionResult>,
+    },
+}
+
+/// 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),
+}
+
+impl WFMachinesError {
+    pub fn evict_reason(&self) -> EvictionReason {
+        match self {
+            WFMachinesError::Nondeterminism(_) => EvictionReason::Nondeterminism,
+            WFMachinesError::Fatal(_) | WFMachinesError::HistoryFetchingError(_) => {
+                EvictionReason::Fatal
+            }
+        }
+    }
+}
+
+impl From<TimestampError> for WFMachinesError {
+    fn from(_: TimestampError) -> Self {
+        Self::Fatal("Could not decode timestamp".to_string())
+    }
+}

data/bridge/sdk-core/core-api/src/lib.rs

@@ -0,0 +1,151 @@
+pub mod errors;
+pub mod worker;
+
+use crate::{
+    errors::{CompleteActivityError, CompleteWfError, PollActivityError, PollWfError},
+    worker::WorkerConfig,
+};
+use log::Level;
+use opentelemetry::metrics::Meter;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+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 represents one worker, which has a (potentially shared) client for connecting to the service
+/// and is bound to a specific task queue.
+#[async_trait::async_trait]
+pub trait Worker: Send + Sync {
+    /// Ask the worker 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 [Worker::shutdown] is called.
+    ///
+    /// 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.
+    async fn poll_workflow_activation(&self) -> Result<WorkflowActivation, PollWfError>;
+
+    /// Ask the worker 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 [Worker::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.
+    async fn poll_activity_task(&self) -> Result<ActivityTask, PollActivityError>;
+
+    /// Tell the worker that a workflow activation has completed. May be freely called concurrently.
+    async fn complete_workflow_activation(
+        &self,
+        completion: WorkflowActivationCompletion,
+    ) -> Result<(), CompleteWfError>;
+
+    /// Tell the worker that an activity has finished executing. May be freely called concurrently.
+    async fn complete_activity_task(
+        &self,
+        completion: ActivityTaskCompletion,
+    ) -> Result<(), CompleteActivityError>;
+
+    /// Notify the Temporal service 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
+    /// [Worker::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, run_id: &str);
+
+    /// Return this worker's config
+    fn get_config(&self) -> &WorkerConfig;
+
+    /// Initiate shutdown. See [Worker::shutdown], this is just a sync version that starts the
+    /// process. You can then wait on `shutdown` or [Worker::finalize_shutdown].
+    fn initiate_shutdown(&self);
+
+    /// Initiates async shutdown procedure, eventually ceases all polling of the server and shuts
+    /// down this worker. [Worker::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
+    /// [Worker::complete_workflow_activation] for those workflows until they are done. At that point,
+    /// the lang SDK can end the process, or drop the [Worker] instance, which will close the
+    /// connection.
+    async fn shutdown(&self);
+
+    /// Completes shutdown and frees all resources. You should avoid simply dropping workers, as
+    /// this does not allow async tasks to report any panics that may have occurred cleanly.
+    ///
+    /// This should be called only after [Worker::shutdown] has resolved.
+    async fn finalize_shutdown(self);
+}
+
+/// Should be backed by a process-wide singleton who is responsible for telemetry and logging
+/// management.
+pub trait CoreTelemetry {
+    /// 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>;
+
+    /// If metrics gathering is enabled, returns the OTel meter for core telemetry, which can be
+    /// used to create metrics instruments, or passed to things that create/record metrics (ex:
+    /// clients).
+    fn get_metric_meter(&self) -> Option<&Meter>;
+}
+
+/// 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()
+    }
+}

data/bridge/sdk-core/core-api/src/worker.rs

@@ -0,0 +1,135 @@
+use std::time::Duration;
+
+/// Defines per-worker configuration options
+#[derive(Debug, Clone, derive_builder::Builder)]
+#[builder(setter(into), build_fn(validate = "Self::validate"))]
+#[non_exhaustive]
+pub struct WorkerConfig {
+    /// The Temporal service namespace this worker is bound to
+    pub namespace: String,
+    /// What task queue will this worker poll from? This task queue name will be used for both
+    /// workflow and activity polling.
+    pub task_queue: String,
+    /// A string that should be unique to the set of code this worker uses. IE: All the workflow,
+    /// activity, interceptor, and data converter code.
+    pub worker_build_id: String,
+    /// A human-readable string that can identify this worker. Using something like sdk version
+    /// and host name is a good default. If set, overrides the identity set (if any) on the client
+    /// used by this worker.
+    #[builder(default)]
+    pub client_identity_override: Option<String>,
+    /// If set nonzero, workflows will be cached and sticky task queues will be used, meaning that
+    /// history updates are applied incrementally to suspended instances of workflow execution.
+    /// Workflows are evicted according to a least-recently-used policy one the cache maximum is
+    /// reached. Workflows may also be explicitly evicted at any time, or as a result of errors
+    /// or failures.
+    #[builder(default = "0")]
+    pub max_cached_workflows: usize,
+    /// The maximum allowed number of workflow tasks that will ever be given to this worker at one
+    /// time. Note that one workflow task may require multiple activations - so the WFT counts as
+    /// "outstanding" until all activations it requires have been completed.
+    ///
+    /// Cannot be larger than `max_cached_workflows`.
+    #[builder(default = "100")]
+    pub max_outstanding_workflow_tasks: usize,
+    /// 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.
+    #[builder(default = "5")]
+    pub max_concurrent_wft_polls: usize,
+    /// [WorkerConfig::max_concurrent_wft_polls] * this number = the number of max pollers that will
+    /// be allowed for the nonsticky queue when sticky tasks are enabled. If both defaults are used,
+    /// the sticky queue will allow 4 max pollers while the nonsticky queue will allow one. The
+    /// minimum for either poller is 1, so if `max_concurrent_wft_polls` is 1 and sticky queues are
+    /// enabled, there will be 2 concurrent polls.
+    #[builder(default = "0.2")]
+    pub nonsticky_to_sticky_poll_ratio: f32,
+    /// Maximum number of concurrent poll activity task requests we will perform at a time on this
+    /// worker's task queue
+    #[builder(default = "5")]
+    pub max_concurrent_at_polls: usize,
+    /// If set to true this worker will only handle workflow tasks and local activities, it will not
+    /// poll for activity tasks.
+    #[builder(default = "false")]
+    pub no_remote_activities: bool,
+    /// How long a workflow task is allowed to sit on the sticky queue before it is timed out
+    /// and moved to the non-sticky queue where it may be picked up by any worker.
+    #[builder(default = "Duration::from_secs(10)")]
+    pub sticky_queue_schedule_to_start_timeout: Duration,
+
+    /// Longest interval for throttling activity heartbeats
+    #[builder(default = "Duration::from_secs(60)")]
+    pub max_heartbeat_throttle_interval: Duration,
+
+    /// Default interval for throttling activity heartbeats in case
+    /// `ActivityOptions.heartbeat_timeout` is unset.
+    /// When the timeout *is* set in the `ActivityOptions`, throttling is set to
+    /// `heartbeat_timeout * 0.8`.
+    #[builder(default = "Duration::from_secs(30)")]
+    pub default_heartbeat_throttle_interval: Duration,
+
+    /// Sets the maximum number of activities per second the task queue will dispatch, controlled
+    /// server-side. Note that this only takes effect upon an activity poll request. If multiple
+    /// workers on the same queue have different values set, they will thrash with the last poller
+    /// winning.
+    #[builder(default)]
+    pub max_task_queue_activities_per_second: Option<f64>,
+
+    /// Limits the number of activities per second that this worker will process. The worker will
+    /// not poll for new activities if by doing so it might receive and execute an activity which
+    /// would cause it to exceed this limit. Negative, zero, or NaN values will cause building
+    /// the options to fail.
+    #[builder(default)]
+    pub max_worker_activities_per_second: Option<f64>,
+
+    /// # UNDER DEVELOPMENT
+    /// If set to true this worker will opt-in to the whole-worker versioning feature.
+    /// `worker_build_id` will be used as the version.
+    /// todo: link to feature docs
+    #[builder(default = "false")]
+    pub use_worker_versioning: bool,
+}
+
+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) {
+            return Err("`max_concurrent_wft_polls` must be at least 1".to_owned());
+        }
+        if self.max_cached_workflows > Some(0)
+            && self.max_outstanding_workflow_tasks > self.max_cached_workflows
+        {
+            return Err(
+                "Maximum concurrent workflow tasks cannot exceed the maximum number of cached \
+                 workflows"
+                    .to_owned(),
+            );
+        }
+        if let Some(Some(ref x)) = self.max_worker_activities_per_second {
+            if !x.is_normal() || x.is_sign_negative() {
+                return Err(
+                    "`max_worker_activities_per_second` must be positive and nonzero".to_owned(),
+                );
+            }
+        }
+        Ok(())
+    }
+}

data/bridge/sdk-core/etc/deps.svg

@@ -0,0 +1,187 @@
+<?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.43.0 (0)
+ -->
+<!-- Title: %3 Pages: 1 -->
+<svg width="525pt" height="476pt"
+ viewBox="0.00 0.00 524.50 476.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 472)">
+<title>%3</title>
+<polygon fill="white" stroke="transparent" points="-4,4 -4,-472 520.5,-472 520.5,4 -4,4"/>
+<!-- 0 -->
+<g id="node1" class="node">
+<title>0</title>
+<polygon fill="none" stroke="black" points="173,-468 0,-468 0,-432 173,-432 173,-468"/>
+<text text-anchor="middle" x="86.5" y="-446.3" font-family="Times,serif" font-size="14.00">temporal&#45;sdk&#45;core&#45;bridge&#45;ffi</text>
+</g>
+<!-- 1 -->
+<g id="node2" class="node">
+<title>1</title>
+<polygon fill="none" stroke="black" points="369.5,-396 253.5,-396 253.5,-360 369.5,-360 369.5,-396"/>
+<text text-anchor="middle" x="311.5" y="-374.3" font-family="Times,serif" font-size="14.00">temporal&#45;sdk&#45;core</text>
+</g>
+<!-- 0&#45;&gt;1 -->
+<g id="edge1" class="edge">
+<title>0&#45;&gt;1</title>
+<path fill="none" stroke="black" d="M141.25,-431.97C173.1,-422.06 213.42,-409.51 246.83,-399.12"/>
+<polygon fill="black" stroke="black" points="247.99,-402.42 256.5,-396.11 245.91,-395.74 247.99,-402.42"/>
+</g>
+<!-- 6 -->
+<g id="node5" class="node">
+<title>6</title>
+<polygon fill="none" stroke="black" points="401,-36 246,-36 246,0 401,0 401,-36"/>
+<text text-anchor="middle" x="323.5" y="-14.3" font-family="Times,serif" font-size="14.00">temporal&#45;sdk&#45;core&#45;protos</text>
+</g>
+<!-- 0&#45;&gt;6 -->
+<g id="edge3" class="edge">
+<title>0&#45;&gt;6</title>
+<path fill="none" stroke="black" d="M78.81,-431.91C67.71,-405.62 48.5,-353.45 48.5,-307 48.5,-307 48.5,-307 48.5,-161 48.5,-75.33 155.16,-41.29 235.63,-27.8"/>
+<polygon fill="black" stroke="black" points="236.47,-31.21 245.8,-26.18 235.37,-24.3 236.47,-31.21"/>
+</g>
+<!-- 7 -->
+<g id="node6" class="node">
+<title>7</title>
+<polygon fill="none" stroke="black" points="266,-180 129,-180 129,-144 266,-144 266,-180"/>
+<text text-anchor="middle" x="197.5" y="-158.3" font-family="Times,serif" font-size="14.00">temporal&#45;sdk&#45;core&#45;api</text>
+</g>
+<!-- 0&#45;&gt;7 -->
+<g id="edge2" class="edge">
+<title>0&#45;&gt;7</title>
+<path fill="none" stroke="black" d="M85.71,-431.86C84.92,-401.65 85.97,-337.48 105.5,-288 120.88,-249.04 151.5,-211.31 173.18,-187.68"/>
+<polygon fill="black" stroke="black" points="175.88,-189.92 180.16,-180.23 170.77,-185.14 175.88,-189.92"/>
+</g>
+<!-- 2 -->
+<g id="node3" class="node">
+<title>2</title>
+<polygon fill="none" stroke="black" points="172.5,-324 114.5,-324 114.5,-288 172.5,-288 172.5,-324"/>
+<text text-anchor="middle" x="143.5" y="-302.3" font-family="Times,serif" font-size="14.00">rustfsm</text>
+</g>
+<!-- 1&#45;&gt;2 -->
+<g id="edge4" class="edge">
+<title>1&#45;&gt;2</title>
+<path fill="none" stroke="black" d="M270.4,-359.88C243.41,-348.63 208.34,-334.02 181.91,-323"/>
+<polygon fill="black" stroke="black" points="183.17,-319.74 172.59,-319.12 180.47,-326.2 183.17,-319.74"/>
+</g>
+<!-- 5 -->
+<g id="node4" class="node">
+<title>5</title>
+<polygon fill="none" stroke="black" points="412.5,-108 312.5,-108 312.5,-72 412.5,-72 412.5,-108"/>
+<text text-anchor="middle" x="362.5" y="-86.3" font-family="Times,serif" font-size="14.00">temporal&#45;client</text>
+</g>
+<!-- 1&#45;&gt;5 -->
+<g id="edge5" class="edge">
+<title>1&#45;&gt;5</title>
+<path fill="none" stroke="black" d="M369.63,-361.71C391.38,-353.54 414.82,-341.45 431.5,-324 455.23,-299.18 453.17,-285.75 459.5,-252 462.45,-236.27 464.68,-231.14 459.5,-216 445.69,-175.67 412.97,-138.29 389.35,-115.12"/>
+<polygon fill="black" stroke="black" points="391.67,-112.5 382.03,-108.11 386.83,-117.55 391.67,-112.5"/>
+</g>
+<!-- 1&#45;&gt;6 -->
+<g id="edge8" class="edge">
+<title>1&#45;&gt;6</title>
+<path fill="none" stroke="black" d="M369.7,-363.34C430.3,-345.24 516.5,-306.87 516.5,-235 516.5,-235 516.5,-235 516.5,-161 516.5,-98.28 449.55,-60.18 394.51,-39.46"/>
+<polygon fill="black" stroke="black" points="395.69,-36.16 385.1,-36.04 393.3,-42.74 395.69,-36.16"/>
+</g>
+<!-- 1&#45;&gt;7 -->
+<g id="edge7" class="edge">
+<title>1&#45;&gt;7</title>
+<path fill="none" stroke="black" d="M264.03,-359.96C247.39,-351.64 230.2,-339.91 219.5,-324 192.37,-283.65 191.8,-224.66 194.32,-190.41"/>
+<polygon fill="black" stroke="black" points="197.83,-190.49 195.22,-180.22 190.86,-189.87 197.83,-190.49"/>
+</g>
+<!-- 8 -->
+<g id="node7" class="node">
+<title>8</title>
+<polygon fill="none" stroke="black" points="450,-252 361,-252 361,-216 450,-216 450,-252"/>
+<text text-anchor="middle" x="405.5" y="-230.3" font-family="Times,serif" font-size="14.00">temporal&#45;sdk</text>
+</g>
+<!-- 1&#45;&gt;8 -->
+<g id="edge6" class="edge">
+<title>1&#45;&gt;8</title>
+<path fill="none" stroke="blue" d="M354.05,-359.78C369.82,-351.61 386.07,-340.02 395.5,-324 406.38,-305.52 405.76,-280.93 404.34,-262.27"/>
+<polygon fill="blue" stroke="blue" points="407.81,-261.75 403.49,-252.07 400.83,-262.32 407.81,-261.75"/>
+</g>
+<!-- 9 -->
+<g id="node8" class="node">
+<title>9</title>
+<polygon fill="none" stroke="black" points="395,-324 228,-324 228,-288 395,-288 395,-324"/>
+<text text-anchor="middle" x="311.5" y="-302.3" font-family="Times,serif" font-size="14.00">temporal&#45;sdk&#45;core&#45;test&#45;utils</text>
+</g>
+<!-- 1&#45;&gt;9 -->
+<g id="edge9" class="edge">
+<title>1&#45;&gt;9</title>
+<path fill="none" stroke="blue" d="M305.58,-359.7C304.79,-351.98 304.56,-342.71 304.9,-334.11"/>
+<polygon fill="blue" stroke="blue" points="308.4,-334.32 305.6,-324.1 301.42,-333.84 308.4,-334.32"/>
+</g>
+<!-- 5&#45;&gt;6 -->
+<g id="edge10" class="edge">
+<title>5&#45;&gt;6</title>
+<path fill="none" stroke="black" d="M352.86,-71.7C348.37,-63.64 342.94,-53.89 337.98,-44.98"/>
+<polygon fill="black" stroke="black" points="340.95,-43.14 333.03,-36.1 334.84,-46.54 340.95,-43.14"/>
+</g>
+<!-- 7&#45;&gt;5 -->
+<g id="edge11" class="edge">
+<title>7&#45;&gt;5</title>
+<path fill="none" stroke="black" d="M237.86,-143.88C260.52,-134.26 288.97,-122.19 312.97,-112.01"/>
+<polygon fill="black" stroke="black" points="314.43,-115.2 322.27,-108.07 311.69,-108.75 314.43,-115.2"/>
+</g>
+<!-- 7&#45;&gt;6 -->
+<g id="edge12" class="edge">
+<title>7&#45;&gt;6</title>
+<path fill="none" stroke="black" d="M210.74,-143.85C225.01,-125.62 248.63,-96.14 270.5,-72 279.24,-62.36 289.24,-52.16 298.18,-43.31"/>
+<polygon fill="black" stroke="black" points="300.7,-45.74 305.39,-36.24 295.8,-40.75 300.7,-45.74"/>
+</g>
+<!-- 8&#45;&gt;1 -->
+<g id="edge14" class="edge">
+<title>8&#45;&gt;1</title>
+<path fill="none" stroke="black" d="M416.59,-252.07C423.07,-271.04 426.51,-301.89 413.5,-324 405.57,-337.47 392.82,-347.8 378.95,-355.62"/>
+<polygon fill="black" stroke="black" points="376.99,-352.69 369.71,-360.39 380.2,-358.91 376.99,-352.69"/>
+</g>
+<!-- 8&#45;&gt;5 -->
+<g id="edge13" class="edge">
+<title>8&#45;&gt;5</title>
+<path fill="none" stroke="black" d="M400.31,-215.87C392.95,-191.56 379.4,-146.82 370.68,-118.01"/>
+<polygon fill="black" stroke="black" points="373.95,-116.75 367.71,-108.19 367.25,-118.77 373.95,-116.75"/>
+</g>
+<!-- 8&#45;&gt;6 -->
+<g id="edge16" class="edge">
+<title>8&#45;&gt;6</title>
+<path fill="none" stroke="black" d="M413.59,-215.56C426.78,-184.32 448.83,-117.84 421.5,-72 413.54,-58.64 400.91,-48.45 387.34,-40.75"/>
+<polygon fill="black" stroke="black" points="388.8,-37.56 378.32,-36.04 385.56,-43.77 388.8,-37.56"/>
+</g>
+<!-- 8&#45;&gt;7 -->
+<g id="edge15" class="edge">
+<title>8&#45;&gt;7</title>
+<path fill="none" stroke="black" d="M360.88,-217.98C330.78,-207.86 290.71,-194.37 257.79,-183.29"/>
+<polygon fill="black" stroke="black" points="258.86,-179.96 248.26,-180.08 256.62,-186.59 258.86,-179.96"/>
+</g>
+<!-- 9&#45;&gt;1 -->
+<g id="edge19" class="edge">
+<title>9&#45;&gt;1</title>
+<path fill="none" stroke="black" d="M317.4,-324.1C318.2,-331.79 318.44,-341.05 318.1,-349.67"/>
+<polygon fill="black" stroke="black" points="314.61,-349.48 317.42,-359.7 321.59,-349.96 314.61,-349.48"/>
+</g>
+<!-- 9&#45;&gt;5 -->
+<g id="edge17" class="edge">
+<title>9&#45;&gt;5</title>
+<path fill="none" stroke="black" d="M315.59,-287.85C324.43,-250.75 345.39,-162.81 356.04,-118.1"/>
+<polygon fill="black" stroke="black" points="359.48,-118.77 358.39,-108.23 352.67,-117.15 359.48,-118.77"/>
+</g>
+<!-- 9&#45;&gt;6 -->
+<g id="edge21" class="edge">
+<title>9&#45;&gt;6</title>
+<path fill="none" stroke="black" d="M308.43,-287.86C302.03,-249.05 288.97,-151.64 303.5,-72 305.11,-63.2 308.1,-53.95 311.29,-45.7"/>
+<polygon fill="black" stroke="black" points="314.62,-46.79 315.19,-36.21 308.15,-44.12 314.62,-46.79"/>
+</g>
+<!-- 9&#45;&gt;7 -->
+<g id="edge20" class="edge">
+<title>9&#45;&gt;7</title>
+<path fill="none" stroke="black" d="M297.75,-287.87C277.81,-263.03 240.73,-216.85 217.68,-188.14"/>
+<polygon fill="black" stroke="black" points="220.29,-185.8 211.3,-180.19 214.83,-190.18 220.29,-185.8"/>
+</g>
+<!-- 9&#45;&gt;8 -->
+<g id="edge18" class="edge">
+<title>9&#45;&gt;8</title>
+<path fill="none" stroke="black" d="M334.74,-287.7C346.69,-278.8 361.42,-267.82 374.35,-258.2"/>
+<polygon fill="black" stroke="black" points="376.6,-260.88 382.53,-252.1 372.42,-255.27 376.6,-260.88"/>
+</g>
+</g>
+</svg>

data/bridge/sdk-core/etc/dynamic-config.yaml

@@ -0,0 +1,2 @@
+system.enableActivityLocalDispatch:
+  - value: true