@temporalio/core-bridge 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,7 +20,7 @@
   "license": "MIT",
   "dependencies": {
     "@opentelemetry/api": "^1.1.0",
-    "@temporalio/internal-non-workflow-common": "^1.0.0",
+    "@temporalio/internal-non-workflow-common": "^1.0.1",
     "arg": "^5.0.2",
     "cargo-cp-artifact": "^0.1.6",
     "which": "^2.0.2"
@@ -43,5 +43,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c4fc4dc608bf58701c11b6ae02d1d63b4457718d"
+  "gitHead": "a1dae539e72b6b088b400998d7bef482e8ed52f1"
 }

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

@@ -12,7 +12,7 @@ mod raw;
 mod retry;
 mod workflow_handle;
 
-pub use crate::retry::{CallType, RetryClient};
+pub use crate::retry::{CallType, RetryClient, RETRYABLE_ERROR_CODES};
 pub use raw::WorkflowService;
 pub use workflow_handle::{WorkflowExecutionInfo, WorkflowExecutionResult};
 
@@ -609,6 +609,20 @@ pub trait WorkflowClientTrait {
         payloads: Option<Payloads>,
     ) -> Result<SignalWorkflowExecutionResponse>;
 
+    /// Send signal and start workflow transcationally
+    //#TODO maybe lift the Signal type from sdk::workflow_context::options
+    #[allow(clippy::too_many_arguments)]
+    async fn signal_with_start_workflow_execution(
+        &self,
+        input: Option<Payloads>,
+        task_queue: String,
+        workflow_id: String,
+        workflow_type: String,
+        options: WorkflowOptions,
+        signal_name: String,
+        signal_input: Option<Payloads>,
+    ) -> Result<SignalWithStartWorkflowExecutionResponse>;
+
     /// Request a query of a certain workflow instance
     async fn query_workflow_execution(
         &self,
@@ -697,7 +711,7 @@ impl WorkflowClientTrait for Client {
                 }),
                 task_queue: Some(TaskQueue {
                     name: task_queue,
-                    kind: 0,
+                    kind: TaskQueueKind::Unspecified as i32,
                 }),
                 request_id,
                 workflow_task_timeout: options.task_timeout.map(Into::into),
@@ -928,6 +942,42 @@ impl WorkflowClientTrait for Client {
             .into_inner())
     }
 
+    async fn signal_with_start_workflow_execution(
+        &self,
+        input: Option<Payloads>,
+        task_queue: String,
+        workflow_id: String,
+        workflow_type: String,
+        options: WorkflowOptions,
+        signal_name: String,
+        signal_input: Option<Payloads>,
+    ) -> Result<SignalWithStartWorkflowExecutionResponse> {
+        let request_id = Uuid::new_v4().to_string();
+        Ok(self
+            .wf_svc()
+            .signal_with_start_workflow_execution(SignalWithStartWorkflowExecutionRequest {
+                namespace: self.namespace.clone(),
+                workflow_id,
+                workflow_type: Some(WorkflowType {
+                    name: workflow_type,
+                }),
+                task_queue: Some(TaskQueue {
+                    name: task_queue,
+                    kind: TaskQueueKind::Normal as i32,
+                }),
+                request_id,
+                input,
+                signal_name,
+                signal_input,
+                identity: self.inner.options.identity.clone(),
+                workflow_task_timeout: options.task_timeout.map(Into::into),
+                search_attributes: options.search_attributes.map(Into::into),
+                ..Default::default()
+            })
+            .await?
+            .into_inner())
+    }
+
     async fn query_workflow_execution(
         &self,
         workflow_id: String,

package/sdk-core/client/src/retry.rs

@@ -120,9 +120,9 @@ impl TonicErrorHandler {
     fn new(cfg: RetryConfig, call_type: CallType, call_name: &'static str) -> Self {
         Self {
             max_retries: cfg.max_retries,
-            backoff: cfg.into(),
             call_type,
             call_name,
+            backoff: cfg.into(),
         }
     }
 
@@ -346,6 +346,29 @@ where
         )
     }
 
+    async fn signal_with_start_workflow_execution(
+        &self,
+        input: Option<Payloads>,
+        task_queue: String,
+        workflow_id: String,
+        workflow_type: String,
+        options: WorkflowOptions,
+        signal_name: String,
+        signal_input: Option<Payloads>,
+    ) -> Result<SignalWithStartWorkflowExecutionResponse> {
+        retry_call!(
+            self,
+            signal_with_start_workflow_execution,
+            input.clone(),
+            task_queue.clone(),
+            workflow_id.clone(),
+            workflow_type.clone(),
+            options.clone(),
+            signal_name.clone(),
+            signal_input.clone()
+        )
+    }
+
     async fn query_workflow_execution(
         &self,
         workflow_id: String,
@@ -443,6 +466,17 @@ where
     }
 }
 
+impl<C> RawClientLikeUser for RetryClient<C>
+where
+    C: RawClientLikeUser,
+{
+    type RawClientT = C::RawClientT;
+
+    fn wf_svc(&self) -> Self::RawClientT {
+        self.client.wf_svc()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -597,14 +631,3 @@ mod tests {
         }
     }
 }
-
-impl<C> RawClientLikeUser for RetryClient<C>
-where
-    C: RawClientLikeUser,
-{
-    type RawClientT = C::RawClientT;
-
-    fn wf_svc(&self) -> Self::RawClientT {
-        self.client.wf_svc()
-    }
-}

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

@@ -22,10 +22,13 @@ use std::{
 };
 use temporal_client::WorkflowOptions;
 use temporal_sdk::{ActivityOptions, WfContext};
-use temporal_sdk_core_api::Worker as WorkerTrait;
+use temporal_sdk_core_api::{errors::CompleteActivityError, Worker as WorkerTrait};
 use temporal_sdk_core_protos::{
     coresdk::{
-        activity_result::{activity_resolution, ActivityExecutionResult, ActivityResolution},
+        activity_result::{
+            activity_execution_result, activity_resolution, ActivityExecutionResult,
+            ActivityResolution, Success,
+        },
         activity_task::{activity_task, ActivityTask},
         workflow_activation::{workflow_activation_job, ResolveActivity, WorkflowActivationJob},
         workflow_commands::{
@@ -801,3 +804,68 @@ async fn activity_tasks_from_completion_reserve_slots() {
     let run_fut = async { worker.run_until_done().await.unwrap() };
     tokio::join!(run_fut, act_completer);
 }
+
+#[tokio::test]
+async fn retryable_net_error_exhaustion_is_nonfatal() {
+    let mut mock_client = mock_workflow_client();
+    mock_client
+        .expect_complete_activity_task()
+        .times(1)
+        .returning(|_, _| Err(tonic::Status::internal("retryable error")));
+
+    let core = mock_worker(MocksHolder::from_client_with_activities(
+        mock_client,
+        [PollActivityTaskQueueResponse {
+            task_token: vec![1],
+            activity_id: "act1".to_string(),
+            heartbeat_timeout: Some(Duration::from_secs(10).into()),
+            ..Default::default()
+        }
+        .into()],
+    ));
+
+    let act = core.poll_activity_task().await.unwrap();
+    core.complete_activity_task(ActivityTaskCompletion {
+        task_token: act.task_token,
+        result: Some(ActivityExecutionResult::ok(vec![1].into())),
+    })
+    .await
+    .unwrap();
+    core.shutdown().await;
+}
+
+#[tokio::test]
+async fn cant_complete_activity_with_unset_result_payload() {
+    let mut mock_client = mock_workflow_client();
+    mock_client
+        .expect_poll_activity_task()
+        .returning(move |_, _| {
+            Ok(PollActivityTaskQueueResponse {
+                task_token: vec![1],
+                ..Default::default()
+            })
+        });
+
+    let cfg = WorkerConfigBuilder::default()
+        .namespace("enchi")
+        .task_queue("cat")
+        .worker_build_id("enchi_loves_salmon")
+        .build()
+        .unwrap();
+    let worker = Worker::new_test(cfg, mock_client);
+    let t = worker.poll_activity_task().await.unwrap();
+    let res = worker
+        .complete_activity_task(ActivityTaskCompletion {
+            task_token: t.task_token,
+            result: Some(ActivityExecutionResult {
+                status: Some(activity_execution_result::Status::Completed(Success {
+                    result: None,
+                })),
+            }),
+        })
+        .await;
+    assert_matches!(
+        res,
+        Err(CompleteActivityError::MalformedActivityCompletion { .. })
+    )
+}

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

@@ -1,20 +1,38 @@
 use crate::{
     replay::{default_wes_attribs, TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE},
-    test_help::{mock_sdk, mock_sdk_cfg, MockPollCfg, ResponseType},
+    test_help::{
+        hist_to_poll_resp, mock_sdk, mock_sdk_cfg, mock_worker, single_hist_mock_sg, MockPollCfg,
+        ResponseType, TEST_Q,
+    },
     worker::client::mocks::mock_workflow_client,
 };
 use anyhow::anyhow;
-use futures::future::join_all;
+use futures::{future::join_all, FutureExt};
 use std::{
-    sync::atomic::{AtomicUsize, Ordering},
+    collections::HashMap,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
     time::Duration,
 };
 use temporal_client::WorkflowOptions;
 use temporal_sdk::{ActContext, LocalActivityOptions, WfContext, WorkflowResult};
+use temporal_sdk_core_api::Worker;
 use temporal_sdk_core_protos::{
-    coresdk::AsJsonPayloadExt,
-    temporal::api::{common::v1::RetryPolicy, enums::v1::EventType, failure::v1::Failure},
+    coresdk::{
+        activity_result::ActivityExecutionResult,
+        workflow_activation::{workflow_activation_job, WorkflowActivationJob},
+        workflow_commands::{ActivityCancellationType, QueryResult, QuerySuccess},
+        workflow_completion::WorkflowActivationCompletion,
+        ActivityTaskCompletion, AsJsonPayloadExt,
+    },
+    temporal::api::{
+        common::v1::RetryPolicy, enums::v1::EventType, failure::v1::Failure,
+        query::v1::WorkflowQuery,
+    },
 };
+use temporal_sdk_core_test_utils::{schedule_local_activity_cmd, WorkerTestHelpers};
 use tokio::sync::Barrier;
 
 async fn echo(_ctx: ActContext, e: String) -> anyhow::Result<String> {
@@ -117,10 +135,7 @@ async fn local_act_many_concurrent() {
     let mut worker = mock_sdk(mh);
 
     worker.register_wf(DEFAULT_WORKFLOW_TYPE.to_owned(), local_act_fanout_wf);
-    worker.register_activity(
-        "echo",
-        |_ctx: ActContext, str: String| async move { Ok(str) },
-    );
+    worker.register_activity("echo", echo);
     worker
         .submit_wf(
             wf_id.to_owned(),
@@ -343,3 +358,158 @@ async fn local_act_retry_long_backoff_uses_timer() {
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
+
+#[tokio::test]
+async fn local_act_null_result() {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    t.add_local_activity_marker(1, "1", None, None, None);
+    t.add_workflow_execution_completed();
+
+    let wf_id = "fakeid";
+    let mock = mock_workflow_client();
+    let mh = MockPollCfg::from_resp_batches(wf_id, t, [ResponseType::AllHistory], mock);
+    let mut worker = mock_sdk_cfg(mh, |w| w.max_cached_workflows = 1);
+
+    worker.register_wf(
+        DEFAULT_WORKFLOW_TYPE.to_owned(),
+        |ctx: WfContext| async move {
+            ctx.local_activity(LocalActivityOptions {
+                activity_type: "nullres".to_string(),
+                input: "hi".as_json_payload().expect("serializes fine"),
+                ..Default::default()
+            })
+            .await;
+            Ok(().into())
+        },
+    );
+    worker.register_activity("nullres", |_ctx: ActContext, _: String| async { Ok(()) });
+    worker
+        .submit_wf(
+            wf_id.to_owned(),
+            DEFAULT_WORKFLOW_TYPE.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
+#[tokio::test]
+async fn query_during_wft_heartbeat_doesnt_accidentally_fail_to_continue_heartbeat() {
+    crate::telemetry::test_telem_console();
+    let wfid = "fake_wf_id";
+    let mut t = TestHistoryBuilder::default();
+    let mut wes_short_wft_timeout = default_wes_attribs();
+    wes_short_wft_timeout.workflow_task_timeout = Some(Duration::from_millis(200).into());
+    t.add(
+        EventType::WorkflowExecutionStarted,
+        wes_short_wft_timeout.into(),
+    );
+    t.add_full_wf_task();
+    // get query here
+    t.add_full_wf_task();
+    t.add_local_activity_marker(1, "1", None, None, None);
+    t.add_workflow_execution_completed();
+
+    let query_with_hist_task = {
+        let mut pr = hist_to_poll_resp(&t, wfid, ResponseType::ToTaskNum(1), TEST_Q);
+        pr.queries = HashMap::new();
+        pr.queries.insert(
+            "the-query".to_string(),
+            WorkflowQuery {
+                query_type: "query-type".to_string(),
+                query_args: Some(b"hi".into()),
+                header: None,
+            },
+        );
+        pr
+    };
+    let after_la_resolved = Arc::new(Barrier::new(2));
+    let poll_barr = after_la_resolved.clone();
+    let tasks = [
+        query_with_hist_task,
+        hist_to_poll_resp(
+            &t,
+            wfid,
+            ResponseType::UntilResolved(
+                async move {
+                    poll_barr.wait().await;
+                }
+                .boxed(),
+                3,
+            ),
+            TEST_Q,
+        ),
+    ];
+    let mock = mock_workflow_client();
+    let mut mock = single_hist_mock_sg(wfid, t, tasks, mock, true);
+    mock.worker_cfg(|wc| wc.max_cached_workflows = 1);
+    let core = mock_worker(mock);
+
+    let barrier = Barrier::new(2);
+
+    let wf_fut = async {
+        let task = core.poll_workflow_activation().await.unwrap();
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+            task.run_id,
+            schedule_local_activity_cmd(
+                1,
+                "act-id",
+                ActivityCancellationType::TryCancel,
+                Duration::from_secs(60),
+            ),
+        ))
+        .await
+        .unwrap();
+        let task = core.poll_workflow_activation().await.unwrap();
+        // Get query, and complete it
+        let query = assert_matches!(
+            task.jobs.as_slice(),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
+            }] => q
+        );
+        // Now complete the LA
+        barrier.wait().await;
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+            task.run_id,
+            QueryResult {
+                query_id: query.query_id.clone(),
+                variant: Some(
+                    QuerySuccess {
+                        response: Some("whatever".into()),
+                    }
+                    .into(),
+                ),
+            }
+            .into(),
+        ))
+        .await
+        .unwrap();
+        // Activation with it resolving:
+        let task = core.poll_workflow_activation().await.unwrap();
+        assert_matches!(
+            task.jobs.as_slice(),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(_)),
+            }]
+        );
+        core.complete_execution(&task.run_id).await;
+    };
+    let act_fut = async {
+        let act_task = core.poll_activity_task().await.unwrap();
+        barrier.wait().await;
+        core.complete_activity_task(ActivityTaskCompletion {
+            task_token: act_task.task_token,
+            result: Some(ActivityExecutionResult::ok(vec![1].into())),
+        })
+        .await
+        .unwrap();
+        after_la_resolved.wait().await;
+    };
+
+    tokio::join!(wf_fut, act_fut);
+}

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

@@ -1,7 +1,7 @@
 use crate::{
     test_help::{
         build_fake_worker, build_mock_pollers, canned_histories, mock_manual_poller, mock_worker,
-        MockPollCfg, MockWorkerInputs, MocksHolder,
+        MockPollCfg, MockWorkerInputs, MocksHolder, ResponseType,
     },
     worker::client::mocks::mock_workflow_client,
     PollActivityError, PollWfError,
@@ -224,3 +224,35 @@ async fn complete_eviction_after_shutdown_doesnt_panic() {
         .await
         .unwrap();
 }
+
+#[tokio::test]
+async fn worker_does_not_panic_on_retry_exhaustion_of_nonfatal_net_err() {
+    let t = canned_histories::single_timer("1");
+    let mut mock = mock_workflow_client();
+    // Return a failure that counts as retryable, and hence we want to be swallowed
+    mock.expect_complete_workflow_task()
+        .times(1)
+        .returning(|_| Err(tonic::Status::internal("Some retryable error")));
+    let mut mh =
+        MockPollCfg::from_resp_batches("fakeid", t, [1.into(), ResponseType::AllHistory], mock);
+    mh.enforce_correct_number_of_polls = false;
+    let mut mock = build_mock_pollers(mh);
+    mock.worker_cfg(|w| w.max_cached_workflows = 1);
+    let core = mock_worker(mock);
+
+    let res = core.poll_workflow_activation().await.unwrap();
+    assert_eq!(res.jobs.len(), 1);
+    // This should not return a fatal error
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+        res.run_id,
+        vec![start_timer_cmd(1, Duration::from_secs(1))],
+    ))
+    .await
+    .unwrap();
+    // We should see an eviction
+    let res = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        res.jobs[0].variant,
+        Some(workflow_activation_job::Variant::RemoveFromCache(_))
+    );
+}

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

@@ -62,7 +62,17 @@ lazy_static::lazy_static! {
     };
 }
 
-/// Initialize a worker bound to a task queue
+/// Initialize a worker bound to a task queue.
+///
+/// Lang implementations should pass in a a [temporal_client::ConfiguredClient] directly (or a
+/// [RetryClient] wrapping one). When they do so, this function will always overwrite the client
+/// retry configuration, force the client to use the namespace defined in the worker config, and set
+/// the client identity appropriately. IE: Use [ClientOptions::connect_no_namespace], not
+/// [ClientOptions::connect].
+///
+/// It is also possible to pass in a [WorkflowClientTrait] implementor, but this largely exists to
+/// support testing and mocking. Lang impls should not operate that way, as it may result in
+/// improper retry behavior for a worker.
 pub fn init_worker<CT>(worker_config: WorkerConfig, client: CT) -> Worker
 where
     CT: Into<AnyClient>,
@@ -76,19 +86,18 @@ where
             if let Some(ref id_override) = worker_config.client_identity_override {
                 client.options_mut().identity = id_override.clone();
             }
-            let retry_client = RetryClient::new(client, RetryConfig::default());
+            let retry_client = RetryClient::new(client, Default::default());
             Arc::new(retry_client)
         }
     };
-    let c_opts = client.get_options().clone();
     if client.namespace() != worker_config.namespace {
         panic!("Passed in client is not bound to the same namespace as the worker");
     }
+    let sticky_q = sticky_q_name_for_worker(&client.get_options().identity, &worker_config);
     let client_bag = Arc::new(WorkerClientBag::new(
         Box::new(client),
         worker_config.namespace.clone(),
     ));
-    let sticky_q = sticky_q_name_for_worker(&c_opts.identity, &worker_config);
     let metrics = MetricsContext::top_level(worker_config.namespace.clone())
         .with_task_q(worker_config.task_queue.clone());
     Worker::new(worker_config, sticky_q, client_bag, metrics)

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

@@ -6,7 +6,7 @@ use anyhow::anyhow;
 use std::{
     collections::HashMap,
     convert::TryFrom,
-    fmt::{Display, Formatter},
+    fmt::{Debug, Display, Formatter},
     time::{Duration, SystemTime},
 };
 use temporal_sdk_core_protos::{
@@ -39,7 +39,7 @@ use temporal_sdk_core_protos::{
 };
 
 /// A validated version of a [PollWorkflowTaskQueueResponse]
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Clone, PartialEq)]
 #[allow(clippy::manual_non_exhaustive)] // Clippy doesn't understand it's only for *in* this crate
 pub struct ValidPollWFTQResponse {
     pub task_token: TaskToken,
@@ -61,6 +61,28 @@ pub struct ValidPollWFTQResponse {
     _cant_construct_me: (),
 }
 
+impl Debug for ValidPollWFTQResponse {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "ValidWFT {{ task_token: {}, task_queue: {}, workflow_execution: {:?}, \
+             workflow_type: {}, attempt: {}, previous_started_event_id: {}, started_event_id {}, \
+             history_length: {}, first_evt_in_hist_id: {:?}, legacy_query: {:?}, queries: {:?} }}",
+            self.task_token,
+            self.task_queue,
+            self.workflow_execution,
+            self.workflow_type,
+            self.attempt,
+            self.previous_started_event_id,
+            self.started_event_id,
+            self.history.events.len(),
+            self.history.events.get(0).map(|e| e.event_id),
+            self.legacy_query,
+            self.query_requests
+        )
+    }
+}
+
 impl TryFrom<PollWorkflowTaskQueueResponse> for ValidPollWFTQResponse {
     /// We return the poll response itself if it was invalid
     type Error = PollWorkflowTaskQueueResponse;
@@ -204,11 +226,10 @@ impl HistoryEventExt for HistoryEvent {
                 )) if marker_name == LOCAL_ACTIVITY_MARKER_NAME => {
                     let (data, ok_res) = extract_local_activity_marker_details(&mut details);
                     let data = data?;
-                    let result = if let Some(r) = ok_res {
-                        Ok(r)
-                    } else {
-                        let fail = failure?;
-                        Err(fail)
+                    let result = match (ok_res, failure) {
+                        (Some(r), None) => Ok(r),
+                        (None | Some(_), Some(f)) => Err(f),
+                        (None, None) => Ok(Default::default()),
                     };
                     Some(CompleteLocalActivityData {
                         marker_dat: data,
@@ -228,6 +249,22 @@ pub(crate) struct CompleteLocalActivityData {
     pub result: Result<Payload, Failure>,
 }
 
+pub(crate) fn validate_activity_completion(
+    status: &activity_execution_result::Status,
+) -> Result<(), CompleteActivityError> {
+    match status {
+        Status::Completed(c) if c.result.is_none() => {
+            Err(CompleteActivityError::MalformedActivityCompletion {
+                reason: "Activity completions must contain a `result` payload \
+                             (which may be empty)"
+                    .to_string(),
+                completion: None,
+            })
+        }
+        _ => Ok(()),
+    }
+}
+
 impl TryFrom<activity_execution_result::Status> for LocalActivityExecutionResult {
     type Error = CompleteActivityError;