@temporalio/core-bridge 1.11.6 → 1.11.8

package/sdk-core/core/src/core_tests/workflow_tasks.rs

@@ -1,56 +1,57 @@
 use crate::{
-    advance_fut,
+    Worker, advance_fut,
     internal_flags::CoreInternalFlags,
     job_assert,
     replay::TestHistoryBuilder,
     test_help::{
+        FakeWfResponses, MockPollCfg, MocksHolder, ResponseType, WorkerExt,
+        WorkflowCachingPolicy::{self, AfterEveryReply, NonSticky},
         build_fake_worker, build_mock_pollers, build_multihist_mock_sg, canned_histories,
         gen_assert_and_fail, gen_assert_and_reply, hist_to_poll_resp, mock_sdk, mock_sdk_cfg,
         mock_worker, poll_and_reply, poll_and_reply_clears_outstanding_evicts, single_hist_mock_sg,
-        test_worker_cfg, FakeWfResponses, MockPollCfg, MocksHolder, ResponseType, WorkerExt,
-        WorkflowCachingPolicy::{self, AfterEveryReply, NonSticky},
+        test_worker_cfg,
     },
     worker::{
-        client::mocks::{mock_manual_workflow_client, mock_workflow_client},
         TunerBuilder,
+        client::mocks::{mock_manual_workflow_client, mock_workflow_client},
     },
-    Worker,
 };
-use futures_util::{stream, FutureExt};
+use futures_util::{FutureExt, stream};
 use mockall::TimesRange;
 use rstest::{fixture, rstest};
 use std::{
     collections::{HashMap, HashSet, VecDeque},
     sync::{
+        Arc,
         atomic::{AtomicU64, AtomicUsize, Ordering},
         mpsc::sync_channel,
-        Arc,
     },
     time::Duration,
 };
 use temporal_client::WorkflowOptions;
-use temporal_sdk::{ActivityOptions, CancellableFuture, WfContext};
+use temporal_sdk::{ActivityOptions, CancellableFuture, TimerOptions, WfContext};
 use temporal_sdk_core_api::{
-    errors::PollWfError,
+    Worker as WorkerTrait,
+    errors::PollError,
     worker::{
         SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext, SlotSupplier,
         SlotSupplierPermit, WorkflowSlotKind,
     },
-    Worker as WorkerTrait,
 };
 use temporal_sdk_core_protos::{
+    DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE,
     coresdk::{
-        activity_result::{self as ar, activity_resolution, ActivityResolution},
+        activity_result::{self as ar, ActivityResolution, activity_resolution},
         common::VersioningIntent,
         workflow_activation::{
-            remove_from_cache::EvictionReason, workflow_activation_job, FireTimer,
-            InitializeWorkflow, ResolveActivity, UpdateRandomSeed, WorkflowActivationJob,
+            FireTimer, InitializeWorkflow, ResolveActivity, UpdateRandomSeed,
+            WorkflowActivationJob, remove_from_cache::EvictionReason, workflow_activation_job,
         },
         workflow_commands::{
-            update_response::Response, workflow_command, ActivityCancellationType, CancelTimer,
-            CompleteWorkflowExecution, ContinueAsNewWorkflowExecution, FailWorkflowExecution,
-            RequestCancelActivity, ScheduleActivity, SetPatchMarker, StartChildWorkflowExecution,
-            UpdateResponse,
+            ActivityCancellationType, CancelTimer, CompleteWorkflowExecution,
+            ContinueAsNewWorkflowExecution, FailWorkflowExecution, RequestCancelActivity,
+            ScheduleActivity, SetPatchMarker, StartChildWorkflowExecution, UpdateResponse,
+            update_response::Response, workflow_command,
         },
         workflow_completion::WorkflowActivationCompletion,
     },
@@ -61,16 +62,16 @@ use temporal_sdk_core_protos::{
         enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
         failure::v1::Failure,
         history::v1::{
-            history_event, TimerFiredEventAttributes,
-            WorkflowPropertiesModifiedExternallyEventAttributes,
+            TimerFiredEventAttributes, WorkflowPropertiesModifiedExternallyEventAttributes,
+            history_event,
         },
+        sdk::v1::UserMetadata,
         workflowservice::v1::{
             GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse,
         },
     },
-    DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE,
 };
-use temporal_sdk_core_test_utils::{fanout_tasks, start_timer_cmd, WorkerTestHelpers};
+use temporal_sdk_core_test_utils::{WorkerTestHelpers, fanout_tasks, start_timer_cmd};
 use tokio::{
     join,
     sync::{Barrier, Semaphore},
@@ -139,11 +140,13 @@ async fn single_activity_completion(worker: Worker) {
         &[
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
-                vec![ScheduleActivity {
-                    activity_id: "fake_activity".to_string(),
-                    ..default_act_sched()
-                }
-                .into()],
+                vec![
+                    ScheduleActivity {
+                        activity_id: "fake_activity".to_string(),
+                        ..default_act_sched()
+                    }
+                    .into(),
+                ],
             ),
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::ResolveActivity(_)),
@@ -262,13 +265,15 @@ async fn scheduled_activity_cancellation_try_cancel(hist_batches: &'static [usiz
         &[
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
-                vec![ScheduleActivity {
-                    seq: activity_seq,
-                    activity_id: activity_id.to_string(),
-                    cancellation_type: ActivityCancellationType::TryCancel as i32,
-                    ..default_act_sched()
-                }
-                .into()],
+                vec![
+                    ScheduleActivity {
+                        seq: activity_seq,
+                        activity_id: activity_id.to_string(),
+                        cancellation_type: ActivityCancellationType::TryCancel as i32,
+                        ..default_act_sched()
+                    }
+                    .into(),
+                ],
             ),
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)),
@@ -407,12 +412,14 @@ async fn cancelled_activity_timeout(hist_batches: &'static [usize]) {
         &[
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
-                vec![ScheduleActivity {
-                    seq: activity_seq,
-                    activity_id: activity_id.to_string(),
-                    ..default_act_sched()
-                }
-                .into()],
+                vec![
+                    ScheduleActivity {
+                        seq: activity_seq,
+                        activity_id: activity_id.to_string(),
+                        ..default_act_sched()
+                    }
+                    .into(),
+                ],
             ),
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)),
@@ -559,13 +566,15 @@ async fn verify_activity_cancellation(
         &[
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
-                vec![ScheduleActivity {
-                    seq: activity_seq,
-                    activity_id: activity_seq.to_string(),
-                    cancellation_type: cancel_type as i32,
-                    ..default_act_sched()
-                }
-                .into()],
+                vec![
+                    ScheduleActivity {
+                        seq: activity_seq,
+                        activity_id: activity_seq.to_string(),
+                        cancellation_type: cancel_type as i32,
+                        ..default_act_sched()
+                    }
+                    .into(),
+                ],
             ),
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)),
@@ -627,13 +636,16 @@ async fn verify_activity_cancellation_wait_for_cancellation(activity_id: u32, wo
         &[
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
-                vec![ScheduleActivity {
-                    seq: activity_id,
-                    activity_id: activity_id.to_string(),
-                    cancellation_type: ActivityCancellationType::WaitCancellationCompleted as i32,
-                    ..default_act_sched()
-                }
-                .into()],
+                vec![
+                    ScheduleActivity {
+                        seq: activity_id,
+                        activity_id: activity_id.to_string(),
+                        cancellation_type: ActivityCancellationType::WaitCancellationCompleted
+                            as i32,
+                        ..default_act_sched()
+                    }
+                    .into(),
+                ],
             ),
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)),
@@ -810,13 +822,15 @@ async fn simple_timer_fail_wf_execution(hist_batches: &'static [usize]) {
             ),
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::FireTimer(_)),
-                vec![FailWorkflowExecution {
-                    failure: Some(Failure {
-                        message: "I'm ded".to_string(),
-                        ..Default::default()
-                    }),
-                }
-                .into()],
+                vec![
+                    FailWorkflowExecution {
+                        failure: Some(Failure {
+                            message: "I'm ded".to_string(),
+                            ..Default::default()
+                        }),
+                    }
+                    .into(),
+                ],
             ),
         ],
     )
@@ -1007,13 +1021,15 @@ async fn activity_not_canceled_when_also_completed_repro(hist_batches: &'static
         &[
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
-                vec![ScheduleActivity {
-                    seq: activity_id,
-                    activity_id: "act-1".to_string(),
-                    cancellation_type: ActivityCancellationType::TryCancel as i32,
-                    ..default_act_sched()
-                }
-                .into()],
+                vec![
+                    ScheduleActivity {
+                        seq: activity_id,
+                        activity_id: "act-1".to_string(),
+                        cancellation_type: ActivityCancellationType::TryCancel as i32,
+                        ..default_act_sched()
+                    }
+                    .into(),
+                ],
             ),
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)),
@@ -1108,13 +1124,15 @@ async fn wft_timeout_repro(hist_batches: &'static [usize]) {
         &[
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
-                vec![ScheduleActivity {
-                    seq: activity_id,
-                    activity_id: activity_id.to_string(),
-                    cancellation_type: ActivityCancellationType::TryCancel as i32,
-                    ..default_act_sched()
-                }
-                .into()],
+                vec![
+                    ScheduleActivity {
+                        seq: activity_id,
+                        activity_id: activity_id.to_string(),
+                        cancellation_type: ActivityCancellationType::TryCancel as i32,
+                        ..default_act_sched()
+                    }
+                    .into(),
+                ],
             ),
             gen_assert_and_reply(
                 &job_assert!(
@@ -1320,26 +1338,18 @@ async fn fail_wft_then_recover() {
     // Start an activity instead of a timer, triggering nondeterminism error
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         act.run_id.clone(),
-        vec![ScheduleActivity {
-            activity_id: "fake_activity".to_string(),
-            ..default_act_sched()
-        }
-        .into()],
+        vec![
+            ScheduleActivity {
+                activity_id: "fake_activity".to_string(),
+                ..default_act_sched()
+            }
+            .into(),
+        ],
     ))
     .await
     .unwrap();
     // We must handle an eviction now
-    let evict_act = core.poll_workflow_activation().await.unwrap();
-    assert_eq!(evict_act.run_id, act.run_id);
-    assert_matches!(
-        evict_act.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
-        }]
-    );
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(evict_act.run_id))
-        .await
-        .unwrap();
+    core.handle_eviction().await;
 
     // Workflow starting over, this time issue the right command
     let act = core.poll_workflow_activation().await.unwrap();
@@ -1530,6 +1540,7 @@ async fn failing_wft_doesnt_eat_permit_forever() {
     // row because we purposefully time out rather than spamming.
     for _ in 1..=2 {
         let activation = worker.poll_workflow_activation().await.unwrap();
+        run_id.clone_from(&activation.run_id);
         // Issue a nonsense completion that will trigger a WFT failure
         worker
             .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
@@ -1538,18 +1549,7 @@ async fn failing_wft_doesnt_eat_permit_forever() {
             ))
             .await
             .unwrap();
-        let activation = worker.poll_workflow_activation().await.unwrap();
-        assert_matches!(
-            activation.jobs.as_slice(),
-            [WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
-            },]
-        );
-        run_id.clone_from(&activation.run_id);
-        worker
-            .complete_workflow_activation(WorkflowActivationCompletion::empty(activation.run_id))
-            .await
-            .unwrap();
+        worker.handle_eviction().await;
     }
     assert_eq!(worker.outstanding_workflow_tasks().await, 0);
     // We should be "out of work" because the mock service thinks we didn't complete the last task,
@@ -2043,7 +2043,7 @@ async fn autocompletes_wft_no_work() {
     // work
     assert_matches!(
         core.poll_workflow_activation().await.unwrap_err(),
-        PollWfError::ShutDown
+        PollError::ShutDown
     );
 
     core.shutdown().await;
@@ -2600,6 +2600,7 @@ async fn _do_post_terminal_commands_test(
 
     let act = core.poll_workflow_activation().await.unwrap();
 
+    core.initiate_shutdown();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         act.run_id,
         commands_sent_by_lang,
@@ -2608,7 +2609,7 @@ async fn _do_post_terminal_commands_test(
     .unwrap();
 
     let act = core.poll_workflow_activation().await;
-    assert_matches!(act.unwrap_err(), PollWfError::ShutDown);
+    assert_matches!(act.unwrap_err(), PollError::ShutDown);
     core.shutdown().await;
 }
 
@@ -2810,7 +2811,7 @@ async fn poller_wont_run_ahead_of_task_slots() {
         // This should end up getting shut down after the other routine finishes tasks
         assert_matches!(
             worker.poll_workflow_activation().await.unwrap_err(),
-            PollWfError::ShutDown
+            PollError::ShutDown
         );
     };
     // Wait for a bit concurrently with above, verify no extra tasks got taken, shutdown
@@ -3065,7 +3066,7 @@ async fn slot_provider_cant_hand_out_more_permits_than_cache_size() {
         // This should end up getting shut down after the other routine finishes tasks
         assert_matches!(
             worker.poll_workflow_activation().await.unwrap_err(),
-            PollWfError::ShutDown
+            PollError::ShutDown
         );
     };
     // Wait for a bit concurrently with above, verify no extra tasks got taken, shutdown
@@ -3086,3 +3087,50 @@ async fn slot_provider_cant_hand_out_more_permits_than_cache_size() {
     // polling is not exceeding the task limit
     assert_eq!(popped_tasks.load(Ordering::Relaxed), 10);
 }
+
+#[tokio::test]
+async fn pass_timer_summary_to_metadata() {
+    let t = canned_histories::single_timer("1");
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    let wf_id = mock_cfg.hists[0].wf_id.clone();
+    let wf_type = DEFAULT_WORKFLOW_TYPE;
+    let expected_user_metadata = Some(UserMetadata {
+        summary: Some(b"timer summary".into()),
+        details: None,
+    });
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+        asserts
+            .then(move |wft| {
+                assert_eq!(wft.commands.len(), 1);
+                assert_eq!(wft.commands[0].command_type(), CommandType::StartTimer);
+                assert_eq!(wft.commands[0].user_metadata, expected_user_metadata)
+            })
+            .then(move |wft| {
+                assert_eq!(wft.commands.len(), 1);
+                assert_eq!(
+                    wft.commands[0].command_type(),
+                    CommandType::CompleteWorkflowExecution
+                );
+            });
+    });
+
+    let mut worker = mock_sdk_cfg(mock_cfg, |_| {});
+    worker.register_wf(wf_type, |ctx: WfContext| async move {
+        ctx.timer(TimerOptions {
+            duration: Duration::from_secs(1),
+            summary: Some("timer summary".to_string()),
+        })
+        .await;
+        Ok(().into())
+    });
+    worker
+        .submit_wf(
+            wf_id.to_owned(),
+            wf_type.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}

package/sdk-core/core/src/ephemeral_server/mod.rs

@@ -13,7 +13,7 @@ use std::{
 use temporal_client::ClientOptionsBuilder;
 use tokio::{
     task::spawn_blocking,
-    time::{sleep, Duration},
+    time::{Duration, sleep},
 };
 use tokio_util::io::{StreamReader, SyncIoBridge};
 use url::Url;
@@ -101,7 +101,7 @@ impl TemporalDevServerConfig {
             "frontend.enableUpdateWorkflowExecutionAsyncAccepted=true".to_owned(),
         ];
         if let Some(db_filename) = &self.db_filename {
-            args.push("--filename".to_owned());
+            args.push("--db-filename".to_owned());
             args.push(db_filename.clone());
         }
         if let Some(ui_port) = self.ui_port {
@@ -270,6 +270,8 @@ pub enum EphemeralExe {
         version: EphemeralExeVersion,
         /// Destination directory or the user temp directory if none set.
         dest_dir: Option<String>,
+        /// How long to cache the download for. None means forever.
+        ttl: Option<Duration>,
     },
 }
 
@@ -309,7 +311,11 @@ impl EphemeralExe {
                 }
                 Ok(path)
             }
-            EphemeralExe::CachedDownload { version, dest_dir } => {
+            EphemeralExe::CachedDownload {
+                version,
+                dest_dir,
+                ttl,
+            } => {
                 let dest_dir = dest_dir
                     .as_ref()
                     .map(PathBuf::from)
@@ -334,8 +340,7 @@ impl EphemeralExe {
                     dest.display()
                 );
 
-                // If it already exists, skip
-                if dest.exists() {
+                if dest.exists() && remove_file_past_ttl(ttl, &dest)? {
                     return Ok(dest);
                 }
 
@@ -379,6 +384,7 @@ impl EphemeralExe {
                         &info.archive_url,
                         Path::new(&info.file_to_extract),
                         &dest,
+                        false,
                     )
                     .await?
                     {
@@ -433,7 +439,7 @@ fn get_free_port(bind_ip: &str) -> io::Result<u16> {
         let (socket, _addr) = listen.accept()?;
 
         // Explicitly drop the socket to close the connection from the listening side first
-        std::mem::drop(socket);
+        drop(socket);
     }
 
     Ok(addr.port())
@@ -447,6 +453,7 @@ async fn lazy_download_exe(
     uri: &str,
     file_to_extract: &Path,
     dest: &Path,
+    already_tried_cleaning_old: bool,
 ) -> anyhow::Result<bool> {
     // If it already exists, do not extract
     if dest.exists() {
@@ -474,7 +481,16 @@ async fn lazy_download_exe(
     // This match only gets Ok if the file was downloaded and extracted to the
     // temporary path
     match file {
-        Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => {
+        Err(err) if err.kind() == io::ErrorKind::AlreadyExists => {
+            // If the download lock file exists but is old, delete it and try again, since it may
+            // have been left by an abandoned process.
+            if !already_tried_cleaning_old
+                && temp_dest.metadata()?.modified()?.elapsed()?.as_secs() > 90
+            {
+                std::fs::remove_file(temp_dest)?;
+                return Box::pin(lazy_download_exe(client, uri, file_to_extract, dest, true)).await;
+            }
+
             // Since it already exists, we'll try once a second for 20 seconds
             // to wait for it to be done, then return false so the caller can
             // try again.
@@ -530,7 +546,7 @@ async fn download_and_extract(
     // We have to map the error type to an io error
     let stream = resp
         .bytes_stream()
-        .map(|item| item.map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err)));
+        .map(|item| item.map_err(|err| io::Error::new(io::ErrorKind::Other, err)));
 
     // Since our tar/zip impls use sync IO, we have to create a bridge and run
     // in a blocking closure.
@@ -574,12 +590,36 @@ async fn download_and_extract(
     .await?
 }
 
+/// Remove the file if it's older than the TTL. Returns true if the current file can be re-used,
+/// returns false if it was removed or should otherwise be re-downloaded.
+fn remove_file_past_ttl(ttl: &Option<Duration>, dest: &PathBuf) -> Result<bool, anyhow::Error> {
+    match ttl {
+        None => return Ok(true),
+        Some(ttl) => {
+            if let Ok(mtime) = dest.metadata().and_then(|d| d.modified()) {
+                if mtime.elapsed().unwrap_or_default().lt(ttl) {
+                    return Ok(true);
+                } else {
+                    // Remove so we can re-download
+                    std::fs::remove_file(dest)?;
+                }
+            }
+            // If we couldn't read the mtime something weird is probably up, so
+            // re-download
+        }
+    }
+    Ok(false)
+}
+
 #[cfg(test)]
 mod tests {
-    use super::get_free_port;
+    use super::{get_free_port, remove_file_past_ttl};
     use std::{
         collections::HashSet,
+        env::temp_dir,
+        fs::File,
         net::{TcpListener, TcpStream},
+        time::{Duration, SystemTime},
     };
 
     #[test]
@@ -609,6 +649,22 @@ mod tests {
         }
     }
 
+    #[tokio::test]
+    async fn respects_file_ttl() {
+        let rand_fname = format!("{}", rand::random::<u64>());
+        let temp_dir = temp_dir();
+
+        let dest_file_path = temp_dir.join(format!("core-test-{}", &rand_fname));
+        let dest_file = File::create(&dest_file_path).unwrap();
+        let set_time_to = SystemTime::now() - Duration::from_secs(100);
+        dest_file.set_modified(set_time_to).unwrap();
+
+        remove_file_past_ttl(&Some(Duration::from_secs(60)), &dest_file_path).unwrap();
+
+        // file should be gone
+        assert!(!dest_file_path.exists());
+    }
+
     fn try_listen_and_dial_on(host: &str, port: u16) -> std::io::Result<()> {
         let listener = TcpListener::bind((host, port))?;
         let _stream = TcpStream::connect((host, port))?;
@@ -617,7 +673,7 @@ mod tests {
         let (socket, _addr) = listener.accept()?;
 
         // Explicitly drop the socket to close the connection from the listening side first
-        std::mem::drop(socket);
+        drop(socket);
 
         Ok(())
     }