@temporalio/core-bridge 1.9.0-rc.0 → 1.9.0

package/sdk-core/core/src/worker/workflow/run_cache.rs

@@ -7,13 +7,12 @@ use crate::{
     MetricsContext,
 };
 use lru::LruCache;
-use std::{num::NonZeroUsize, rc::Rc};
+use std::{num::NonZeroUsize, rc::Rc, sync::Arc};
+use temporal_sdk_core_api::worker::WorkerConfig;
 use temporal_sdk_core_protos::temporal::api::workflowservice::v1::get_system_info_response;
 
 pub(super) struct RunCache {
-    max: usize,
-    namespace: String,
-    task_queue: String,
+    worker_config: Arc<WorkerConfig>,
     server_capabilities: get_system_info_response::Capabilities,
     /// Run id -> Data
     runs: LruCache<String, ManagedRun>,
@@ -24,24 +23,20 @@ pub(super) struct RunCache {
 
 impl RunCache {
     pub fn new(
-        max_cache_size: usize,
-        namespace: String,
-        task_queue: String,
+        worker_config: Arc<WorkerConfig>,
         server_capabilities: get_system_info_response::Capabilities,
         local_activity_request_sink: impl LocalActivityRequestSink,
         metrics: MetricsContext,
     ) -> Self {
         // The cache needs room for at least one run, otherwise we couldn't do anything. In
         // "0" size mode, the run is evicted once the workflow task is complete.
-        let lru_size = if max_cache_size > 0 {
-            max_cache_size
+        let lru_size = if worker_config.max_cached_workflows > 0 {
+            worker_config.max_cached_workflows
         } else {
             1
         };
         Self {
-            max: max_cache_size,
-            namespace,
-            task_queue,
+            worker_config,
             server_capabilities,
             runs: LruCache::new(
                 NonZeroUsize::new(lru_size).expect("LRU size is guaranteed positive"),
@@ -68,11 +63,10 @@ impl RunCache {
             .with_new_attrs([workflow_type(pwft.work.workflow_type.clone())]);
         let (mrh, rur) = ManagedRun::new(
             RunBasics {
-                namespace: self.namespace.clone(),
+                worker_config: self.worker_config.clone(),
                 workflow_id: pwft.work.execution.workflow_id.clone(),
                 workflow_type: pwft.work.workflow_type.clone(),
                 run_id: run_id.clone(),
-                task_queue: self.task_queue.clone(),
                 history: HistoryUpdate::dummy(),
                 metrics,
                 capabilities: &self.server_capabilities,
@@ -124,6 +118,6 @@ impl RunCache {
         self.runs.len()
     }
     pub fn cache_capacity(&self) -> usize {
-        self.max
+        self.worker_config.max_cached_workflows
     }
 }

package/sdk-core/core/src/worker/workflow/workflow_stream/saved_wf_inputs.rs

@@ -23,7 +23,7 @@ use tokio_util::sync::CancellationToken;
 ///
 /// Use `CoreWfStarter::enable_wf_state_input_recording` from the integration test utilities to
 /// activate saving the data to disk, and use the `wf_input_replay` example binary to replay.
-pub async fn replay_wf_state_inputs(mut config: WorkerConfig, inputs: impl Stream<Item = Vec<u8>>) {
+pub async fn replay_wf_state_inputs(config: WorkerConfig, inputs: impl Stream<Item = Vec<u8>>) {
     use crate::worker::build_wf_basics;
 
     let la_resp_q = Arc::new(SegQueue::new());
@@ -43,7 +43,7 @@ pub async fn replay_wf_state_inputs(mut config: WorkerConfig, inputs: impl Strea
             })
         });
     let basics = build_wf_basics(
-        &mut config,
+        config,
         MetricsContext::no_op(),
         CancellationToken::new(),
         DEFAULT_TEST_CAPABILITIES.clone(),

package/sdk-core/core/src/worker/workflow/workflow_stream.rs

@@ -95,21 +95,19 @@ impl WFStream {
         let mut state = WFStream {
             buffered_polls_need_cache_slot: Default::default(),
             runs: RunCache::new(
-                basics.max_cached_workflows,
-                basics.namespace.clone(),
-                basics.task_queue.clone(),
+                basics.worker_config.clone(),
                 basics.server_capabilities.clone(),
                 local_activity_request_sink,
                 basics.metrics.clone(),
             ),
             shutdown_token: basics.shutdown_token,
-            ignore_evicts_on_shutdown: basics.ignore_evicts_on_shutdown,
+            ignore_evicts_on_shutdown: basics.worker_config.ignore_evicts_on_shutdown,
             metrics: basics.metrics,
             runs_needing_fetching: Default::default(),
             history_fetch_refcounter: Arc::new(HistfetchRC {}),
 
             #[cfg(feature = "save_wf_inputs")]
-            wf_state_inputs: basics.wf_state_inputs,
+            wf_state_inputs: basics.worker_config.wf_state_inputs.clone(),
         };
         all_inputs
             .map(move |action: WFStreamInput| {
@@ -386,7 +384,7 @@ impl WFStream {
                 // We accept that there might be query tasks remaining in the buffer if we evicted
                 // and re-instantiated here. It's likely those tasks are now invalidated anyway.
                 if maybe_buffered.has_tasks() && should_evict {
-                    panic!("There were leftover buffered tasks");
+                    warn!("There were leftover buffered tasks when evicting run");
                 }
             }
         }

package/sdk-core/core-api/Cargo.toml

@@ -3,7 +3,7 @@ name = "temporal-sdk-core-api"
 version = "0.1.0"
 edition = "2021"
 authors = ["Spencer Judge <spencer@temporal.io>"]
-license-file = "LICENSE.txt"
+license-file = { workspace = true }
 description = "Interface definitions for the Temporal Core SDK"
 homepage = "https://temporal.io/"
 repository = "https://github.com/temporalio/sdk-core"

package/sdk-core/fsm/LICENSE.txt

@@ -1,5 +1,3 @@
-Temporal Core SDK
-
 The MIT License
 
 Copyright (c) 2021 Temporal Technologies, Inc. All Rights Reserved

package/sdk-core/fsm/rustfsm_procmacro/LICENSE.txt

@@ -1,5 +1,3 @@
-Temporal Core SDK
-
 The MIT License
 
 Copyright (c) 2021 Temporal Technologies, Inc. All Rights Reserved

package/sdk-core/fsm/rustfsm_trait/LICENSE.txt

@@ -1,5 +1,3 @@
-Temporal Core SDK
-
 The MIT License
 
 Copyright (c) 2021 Temporal Technologies, Inc. All Rights Reserved

package/sdk-core/sdk/Cargo.toml

@@ -3,7 +3,7 @@ name = "temporal-sdk"
 version = "0.1.0-alpha.1"
 edition = "2021"
 authors = ["Spencer Judge <spencer@temporal.io>"]
-license-file = "LICENSE.txt"
+license-file = { workspace = true }
 description = "Temporal Rust SDK"
 homepage = "https://temporal.io/"
 repository = "https://github.com/temporalio/sdk-core"

package/sdk-core/sdk/src/workflow_future.rs

@@ -236,7 +236,7 @@ impl WorkflowFuture {
                         let defp = Payload::default();
                         let val_res = if u.run_validator {
                             match panic::catch_unwind(AssertUnwindSafe(|| {
-                                (impls.validator)(&info, u.input.get(0).unwrap_or(&defp))
+                                (impls.validator)(&info, u.input.first().unwrap_or(&defp))
                             })) {
                                 Ok(r) => r,
                                 Err(e) => {
@@ -257,7 +257,7 @@ impl WorkflowFuture {
                                         wf_ctx: self.wf_ctx.clone(),
                                         info,
                                     },
-                                    u.input.get(0).unwrap_or(&defp),
+                                    u.input.first().unwrap_or(&defp),
                                 );
                                 self.update_futures
                                     .push((u.protocol_instance_id, handler_fut));

package/sdk-core/sdk-core-protos/Cargo.toml

@@ -3,7 +3,7 @@ name = "temporal-sdk-core-protos"
 version = "0.1.0"
 edition = "2021"
 authors = ["Spencer Judge <spencer@temporal.io>"]
-license-file = "LICENSE.txt"
+license-file = { workspace = true }
 description = "Protobuf definitions for Temporal SDKs Core/Lang interface"
 homepage = "https://temporal.io/"
 repository = "https://github.com/temporalio/sdk-core"

package/sdk-core/sdk-core-protos/protos/api_upstream/temporal/api/batch/v1/message.proto

@@ -90,10 +90,15 @@ message BatchOperationDeletion {
 // BatchOperationReset sends reset requests to batch workflows.
 // Keep the parameter in sync with temporal.api.workflowservice.v1.ResetWorkflowExecutionRequest.
 message BatchOperationReset {
-  // Reset type.
-  temporal.api.enums.v1.ResetType reset_type = 1; 
-  // History event reapply options.
-  temporal.api.enums.v1.ResetReapplyType reset_reapply_type = 2; 
   // The identity of the worker/client.
   string identity = 3;
+
+  // Describes what to reset to and how. If set, `reset_type` and `reset_reapply_type` are ignored.
+  temporal.api.common.v1.ResetOptions options = 4;
+
+  // Reset type (deprecated, use `options`).
+  temporal.api.enums.v1.ResetType reset_type = 1;
+  // History event reapply options (deprecated, use `options`).
+  temporal.api.enums.v1.ResetReapplyType reset_reapply_type = 2;
+
 }

package/sdk-core/sdk-core-protos/protos/api_upstream/temporal/api/common/v1/message.proto

@@ -32,8 +32,10 @@ option ruby_package = "Temporalio::Api::Common::V1";
 option csharp_namespace = "Temporalio.Api.Common.V1";
 
 import "google/protobuf/duration.proto";
+import "google/protobuf/empty.proto";
 
 import "temporal/api/enums/v1/common.proto";
+import "temporal/api/enums/v1/reset.proto";
 
 message DataBlob {
     temporal.api.enums.v1.EncodingType encoding_type = 1;
@@ -147,3 +149,32 @@ message WorkerVersionCapabilities {
 
     // Later, may include info like "I can process WASM and/or JS bundles"
 }
+
+// Describes where and how to reset a workflow, used for batch reset currently
+// and may be used for single-workflow reset later.
+message ResetOptions {
+    // Which workflow task to reset to.
+    oneof target {
+        // Resets to the first workflow task completed or started event.
+        google.protobuf.Empty first_workflow_task = 1;
+        // Resets to the last workflow task completed or started event.
+        google.protobuf.Empty last_workflow_task = 2;
+        // The id of a specific `WORKFLOW_TASK_COMPLETED`,`WORKFLOW_TASK_TIMED_OUT`, `WORKFLOW_TASK_FAILED`, or
+        // `WORKFLOW_TASK_STARTED` event to reset to.
+        // Note that this option doesn't make sense when used as part of a batch request.
+        int64 workflow_task_id = 3;
+        // Resets to the first workflow task processed by this build id.
+        // If the workflow was not processed by the build id, or the workflow task can't be
+        // determined, no reset will be performed.
+        // Note that by default, this reset is allowed to be to a prior run in a chain of
+        // continue-as-new.
+        string build_id = 4;
+    }
+
+    // History event reapply options.
+    temporal.api.enums.v1.ResetReapplyType reset_reapply_type = 10;
+
+    // If true, limit the reset to only within the current run. (Applies to build_id targets and
+    // possibly others in the future.)
+    bool current_run_only = 11;
+}

package/sdk-core/sdk-core-protos/protos/api_upstream/temporal/api/enums/v1/reset.proto

@@ -40,11 +40,11 @@ enum ResetReapplyType {
     RESET_REAPPLY_TYPE_NONE = 2;
 }
 
-// Reset type options
-enum ResetType { 
+// Reset type options. Deprecated, see temporal.api.common.v1.ResetOptions.
+enum ResetType {
     RESET_TYPE_UNSPECIFIED = 0;
     // Resets to event of the first workflow task completed, or if it does not exist, the event after task scheduled.
     RESET_TYPE_FIRST_WORKFLOW_TASK = 1;
     // Resets to event of the last workflow task completed, or if it does not exist, the event after task scheduled.
     RESET_TYPE_LAST_WORKFLOW_TASK = 2;
-}
+}

package/sdk-core/sdk-core-protos/protos/api_upstream/temporal/api/export/v1/message.proto

@@ -24,7 +24,7 @@ syntax = "proto3";
 
 package temporal.api.export.v1;
 
-option go_package = "go.temporal.io/api/export/v1;workflow";
+option go_package = "go.temporal.io/api/export/v1;export";
 option java_package = "io.temporal.api.export.v1";
 option java_multiple_files = true;
 option java_outer_classname = "MessageProto";

package/sdk-core/sdk-core-protos/protos/api_upstream/temporal/api/sdk/v1/workflow_metadata.proto

@@ -0,0 +1,66 @@
+// The MIT License
+//
+// Copyright (c) 2020 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.
+
+syntax = "proto3";
+
+package temporal.api.sdk.v1;
+
+option go_package = "go.temporal.io/api/sdk/v1;sdk";
+option java_package = "io.temporal.api.sdk.v1";
+option java_multiple_files = true;
+option java_outer_classname = "WorkflowMetadataProto";
+option ruby_package = "Temporalio::Api::Sdk::V1";
+option csharp_namespace = "Temporalio.Api.Sdk.V1";
+
+// The name of the query to retrieve this information is `__temporal_getWorkflowMetadata`.
+message WorkflowMetadata {
+  // Metadata provided at declaration or creation time.
+  WorkflowDefinition definition = 1;
+}
+
+// (-- api-linter: core::0203::optional=disabled --)
+message WorkflowDefinition {
+  // A name scoped by the task queue that maps to this workflow definition.
+  // If missing, this workflow is a dynamic workflow.
+  string type = 1;
+  // An optional workflow description provided by the application.
+  // By convention, external tools may interpret its first part,
+  // i.e., ending with a line break, as a summary of the description.
+  string description = 2;
+  repeated WorkflowInteractionDefinition query_definitions = 3;
+  repeated WorkflowInteractionDefinition signal_definitions = 4;
+  repeated WorkflowInteractionDefinition update_definitions = 5;
+}
+
+// (-- api-linter: core::0123::resource-annotation=disabled
+//     aip.dev/not-precedent: The `name` field is optional. --)
+// (-- api-linter: core::0203::optional=disabled --)
+message WorkflowInteractionDefinition {
+  // An optional name for the handler. If missing, it represents
+  // a dynamic handler that processes any interactions not handled by others.
+  // There is at most one dynamic handler per workflow and interaction kind.
+  string name = 1;
+  // An optional interaction description provided by the application.
+  // By convention, external tools may interpret its first part,
+  // i.e., ending with a line break, as a summary of the description.
+  string description = 2; 
+}

package/sdk-core/sdk-core-protos/protos/api_upstream/temporal/api/workflow/v1/message.proto

@@ -106,9 +106,13 @@ message ResetPoints {
     repeated ResetPointInfo points = 1;
 }
 
+// ResetPointInfo records the workflow event id that is the first one processed by a given
+// build id or binary checksum. A new reset point will be created if either build id or binary
+// checksum changes (although in general only one or the other will be used at a time).
 message ResetPointInfo {
-    // A worker binary version identifier, will be deprecated and superseded by a newer concept of
-    // build_id.
+    // Worker build id.
+    string build_id = 7;
+    // A worker binary version identifier (deprecated).
     string binary_checksum = 1;
     // The first run ID in the execution chain that was touched by this worker build.
     string run_id = 2;

package/sdk-core/sdk-core-protos/src/history_info.rs

@@ -37,7 +37,7 @@ impl HistoryInfo {
         let mut workflow_task_started_event_id = 0;
         let mut wf_task_count = 0;
         let mut history = events.iter().peekable();
-        let started_attrs = match &events.get(0).unwrap().attributes {
+        let started_attrs = match &events.first().unwrap().attributes {
             Some(history_event::Attributes::WorkflowExecutionStartedEventAttributes(attrs)) => {
                 attrs.clone()
             }

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

@@ -336,7 +336,7 @@ pub mod coresdk {
         ) -> Option<LocalActivityMarkerData> {
             details
                 .get("data")
-                .and_then(|p| p.payloads.get(0))
+                .and_then(|p| p.payloads.first())
                 .and_then(|p| std::str::from_utf8(&p.data).ok())
                 .and_then(|s| serde_json::from_str(s).ok())
         }

package/sdk-core/test-utils/Cargo.toml

@@ -3,6 +3,7 @@ name = "temporal-sdk-core-test-utils"
 version = "0.1.0"
 authors = ["Spencer Judge <spencer@temporal.io>"]
 edition = "2021"
+license-file = { workspace = true }
 
 [[bin]]
 name = "histfetch"

package/sdk-core/tests/integ_tests/visibility_tests.rs

@@ -35,8 +35,8 @@ async fn client_list_open_closed_workflow_executions() {
 
     // List above OPEN workflow
     let start_time_filter = StartTimeFilter {
-        earliest_time: Some(earliest).and_then(|t| t.try_into().ok()),
-        latest_time: Some(latest).and_then(|t| t.try_into().ok()),
+        earliest_time: Some(earliest).map(|t| t.into()),
+        latest_time: Some(latest).map(|t| t.into()),
     };
     let filter = ListOpenFilters::ExecutionFilter(WorkflowExecutionFilter {
         workflow_id: wf_name.clone(),
@@ -63,8 +63,8 @@ async fn client_list_open_closed_workflow_executions() {
                 1,
                 Default::default(),
                 Some(StartTimeFilter {
-                    earliest_time: Some(earliest).and_then(|t| t.try_into().ok()),
-                    latest_time: Some(latest).and_then(|t| t.try_into().ok()),
+                    earliest_time: Some(earliest).map(|t| t.into()),
+                    latest_time: Some(latest).map(|t| t.into()),
                 }),
                 Some(ListClosedFilters::ExecutionFilter(
                     WorkflowExecutionFilter {

package/sdk-core/tests/integ_tests/workflow_tests.rs

@@ -35,17 +35,19 @@ use temporal_sdk_core_protos::{
     coresdk::{
         activity_result::ActivityExecutionResult,
         workflow_activation::{workflow_activation_job, WorkflowActivation, WorkflowActivationJob},
-        workflow_commands::{ActivityCancellationType, FailWorkflowExecution, StartTimer},
+        workflow_commands::{
+            ActivityCancellationType, FailWorkflowExecution, QueryResult, QuerySuccess, StartTimer,
+        },
         workflow_completion::WorkflowActivationCompletion,
         ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
     },
-    temporal::api::{failure::v1::Failure, history::v1::history_event},
+    temporal::api::{failure::v1::Failure, history::v1::history_event, query::v1::WorkflowQuery},
 };
 use temporal_sdk_core_test_utils::{
     drain_pollers_and_shutdown, history_from_proto_binary, init_core_and_create_wf,
     init_core_replay_preloaded, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
 };
-use tokio::time::sleep;
+use tokio::{join, time::sleep};
 use uuid::Uuid;
 
 // TODO: We should get expected histories for these tests and confirm that the history at the end
@@ -592,3 +594,139 @@ async fn slow_completes_with_small_cache() {
         .await
         .unwrap();
 }
+
+#[tokio::test]
+async fn build_id_correct_in_wf_info() {
+    let wf_type = "build_id_correct_in_wf_info";
+    let mut starter = CoreWfStarter::new(wf_type);
+    starter
+        .worker_config
+        .worker_build_id("1.0")
+        .no_remote_activities(true);
+    let core = starter.get_worker().await;
+    starter.start_wf().await;
+    let client = starter.get_client().await;
+    let workflow_id = starter.get_task_queue().to_string();
+
+    let res = core.poll_workflow_activation().await.unwrap();
+    assert_eq!(res.build_id_for_current_task, "1.0");
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+        res.run_id.clone(),
+        vec![],
+    ))
+    .await
+    .unwrap();
+
+    // Ensure a query on first wft also sees the correct id
+    let query_fut = async {
+        client
+            .query_workflow_execution(
+                workflow_id.clone(),
+                res.run_id.to_string(),
+                WorkflowQuery {
+                    query_type: "q1".to_string(),
+                    ..Default::default()
+                },
+            )
+            .await
+            .unwrap()
+    };
+    let complete_fut = async {
+        let task = core.poll_workflow_activation().await.unwrap();
+        let query = assert_matches!(
+            task.jobs.as_slice(),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
+            }] => q
+        );
+        assert_eq!(task.build_id_for_current_task, "1.0");
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+            task.run_id,
+            QueryResult {
+                query_id: query.query_id.clone(),
+                variant: Some(
+                    QuerySuccess {
+                        response: Some("done".into()),
+                    }
+                    .into(),
+                ),
+            }
+            .into(),
+        ))
+        .await
+        .unwrap();
+    };
+    join!(query_fut, complete_fut);
+    starter.shutdown().await;
+    client
+        .reset_sticky_task_queue(workflow_id.clone(), "".to_string())
+        .await
+        .unwrap();
+
+    let mut starter = starter.clone_no_worker();
+    starter.worker_config.worker_build_id("2.0");
+    let core = starter.get_worker().await;
+
+    let query_fut = async {
+        client
+            .query_workflow_execution(
+                workflow_id.clone(),
+                res.run_id.to_string(),
+                WorkflowQuery {
+                    query_type: "q2".to_string(),
+                    ..Default::default()
+                },
+            )
+            .await
+            .unwrap()
+    };
+    let complete_fut = async {
+        let res = core.poll_workflow_activation().await.unwrap();
+        assert_eq!(res.build_id_for_current_task, "1.0");
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+            res.run_id.clone(),
+            vec![],
+        ))
+        .await
+        .unwrap();
+        let task = core.poll_workflow_activation().await.unwrap();
+        let query = assert_matches!(
+            task.jobs.as_slice(),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
+            }] => q
+        );
+        assert_eq!(task.build_id_for_current_task, "1.0");
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+            task.run_id,
+            QueryResult {
+                query_id: query.query_id.clone(),
+                variant: Some(
+                    QuerySuccess {
+                        response: Some("done".into()),
+                    }
+                    .into(),
+                ),
+            }
+            .into(),
+        ))
+        .await
+        .unwrap();
+    };
+    join!(query_fut, complete_fut);
+
+    client
+        .signal_workflow_execution(
+            workflow_id.clone(),
+            "".to_string(),
+            "whatever".to_string(),
+            None,
+            None,
+        )
+        .await
+        .unwrap();
+
+    let res = core.poll_workflow_activation().await.unwrap();
+    assert_eq!(res.build_id_for_current_task, "2.0");
+    core.complete_execution(&res.run_id).await;
+}