@temporalio/core-bridge 1.11.6 → 1.11.8

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

@@ -1,12 +1,12 @@
 use crate::{
-    panic_formatter, CancellableID, RustWfCmd, SignalData, TimerResult, UnblockEvent,
-    UpdateContext, UpdateFunctions, UpdateInfo, WfContext, WfExitValue, WorkflowFunction,
-    WorkflowResult,
+    CancellableID, RustWfCmd, SignalData, TimerResult, UnblockEvent, UpdateContext,
+    UpdateFunctions, UpdateInfo, WfContext, WfExitValue, WorkflowFunction, WorkflowResult,
+    panic_formatter,
 };
-use anyhow::{anyhow, bail, Context as AnyhowContext, Error};
-use futures_util::{future::BoxFuture, FutureExt};
+use anyhow::{Context as AnyhowContext, Error, anyhow, bail};
+use futures_util::{FutureExt, future::BoxFuture};
 use std::{
-    collections::{hash_map::Entry, HashMap},
+    collections::{HashMap, hash_map::Entry},
     future::Future,
     panic,
     panic::AssertUnwindSafe,
@@ -17,25 +17,26 @@ use std::{
 use temporal_sdk_core_protos::{
     coresdk::{
         workflow_activation::{
-            workflow_activation_job::Variant, FireTimer, NotifyHasPatch, ResolveActivity,
+            FireTimer, InitializeWorkflow, NotifyHasPatch, ResolveActivity,
             ResolveChildWorkflowExecution, ResolveChildWorkflowExecutionStart, WorkflowActivation,
-            WorkflowActivationJob,
+            WorkflowActivationJob, workflow_activation_job::Variant,
         },
         workflow_commands::{
-            request_cancel_external_workflow_execution as cancel_we, update_response,
-            workflow_command, CancelChildWorkflowExecution, CancelSignalWorkflow, CancelTimer,
+            CancelChildWorkflowExecution, CancelSignalWorkflow, CancelTimer,
             CancelWorkflowExecution, CompleteWorkflowExecution, FailWorkflowExecution,
             RequestCancelActivity, RequestCancelExternalWorkflowExecution,
-            RequestCancelLocalActivity, ScheduleActivity, ScheduleLocalActivity,
-            StartChildWorkflowExecution, StartTimer, UpdateResponse,
+            RequestCancelLocalActivity, RequestCancelNexusOperation, ScheduleActivity,
+            ScheduleLocalActivity, StartTimer, UpdateResponse, WorkflowCommand, update_response,
+            workflow_command,
         },
-        workflow_completion::WorkflowActivationCompletion,
+        workflow_completion,
+        workflow_completion::{WorkflowActivationCompletion, workflow_activation_completion},
     },
     temporal::api::{common::v1::Payload, failure::v1::Failure},
     utilities::TryIntoOrNone,
 };
 use tokio::sync::{
-    mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},
+    mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel},
     oneshot, watch,
 };
 use tracing::Instrument;
@@ -43,26 +44,25 @@ use tracing::Instrument;
 impl WorkflowFunction {
     /// Start a workflow function, returning a future that will resolve when the workflow does,
     /// and a channel that can be used to send it activations.
-    #[doc(hidden)]
-    pub fn start_workflow(
+    pub(crate) fn start_workflow(
         &self,
         namespace: String,
         task_queue: String,
-        workflow_type: &str,
-        args: Vec<Payload>,
+        init_workflow_job: InitializeWorkflow,
         outgoing_completions: UnboundedSender<WorkflowActivationCompletion>,
     ) -> (
-        impl Future<Output = WorkflowResult<Payload>>,
+        impl Future<Output = WorkflowResult<Payload>> + use<>,
         UnboundedSender<WorkflowActivation>,
     ) {
-        let (cancel_tx, cancel_rx) = watch::channel(false);
-        let (wf_context, cmd_receiver) = WfContext::new(namespace, task_queue, args, cancel_rx);
-        let (tx, incoming_activations) = unbounded_channel();
+        let (cancel_tx, cancel_rx) = watch::channel(None);
         let span = info_span!(
             "RunWorkflow",
-            "otel.name" = format!("RunWorkflow:{}", workflow_type),
+            "otel.name" = format!("RunWorkflow:{}", &init_workflow_job.workflow_type),
             "otel.kind" = "server"
         );
+        let (wf_context, cmd_receiver) =
+            WfContext::new(namespace, task_queue, init_workflow_job, cancel_rx);
+        let (tx, incoming_activations) = unbounded_channel();
         let inner_fut = (self.wf_func)(wf_context.clone()).instrument(span);
         (
             WorkflowFuture {
@@ -76,7 +76,6 @@ impl WorkflowFunction {
                 incoming_activations,
                 command_status: Default::default(),
                 cancel_sender: cancel_tx,
-                child_workflow_starts: Default::default(),
                 sig_chans: Default::default(),
                 updates: Default::default(),
                 update_futures: Default::default(),
@@ -111,11 +110,9 @@ pub(crate) struct WorkflowFuture {
     /// Commands by ID -> blocked status
     command_status: HashMap<CommandID, WFCommandFutInfo>,
     /// Use to notify workflow code of cancellation
-    cancel_sender: watch::Sender<bool>,
+    cancel_sender: watch::Sender<Option<String>>,
     /// Copy of the workflow context
     wf_ctx: WfContext,
-    /// Mapping of sequence number to a StartChildWorkflowExecution request
-    child_workflow_starts: HashMap<u32, StartChildWorkflowExecution>,
     /// Maps signal IDs to channels to send down when they are signaled
     sig_chans: HashMap<String, SigChanOrBuffer>,
     /// Maps update handlers by name to implementations
@@ -133,6 +130,8 @@ impl WorkflowFuture {
             UnblockEvent::WorkflowComplete(seq, _) => CommandID::ChildWorkflowComplete(seq),
             UnblockEvent::SignalExternal(seq, _) => CommandID::SignalExternal(seq),
             UnblockEvent::CancelExternal(seq, _) => CommandID::CancelExternal(seq),
+            UnblockEvent::NexusOperationStart(seq, _) => CommandID::NexusOpStart(seq),
+            UnblockEvent::NexusOperationComplete(seq, _) => CommandID::NexusOpComplete(seq),
         };
         let unblocker = self.command_status.remove(&cmd_id);
         let _ = unblocker
@@ -153,12 +152,17 @@ impl WorkflowFuture {
             .expect("Completion channel intact");
     }
 
-    fn send_completion(&self, run_id: String, activation_cmds: Vec<workflow_command::Variant>) {
+    fn send_completion(&self, run_id: String, activation_cmds: Vec<WorkflowCommand>) {
         self.outgoing_completions
-            .send(WorkflowActivationCompletion::from_cmds(
+            .send(WorkflowActivationCompletion {
                 run_id,
-                activation_cmds,
-            ))
+                status: Some(workflow_activation_completion::Status::Successful(
+                    workflow_completion::Success {
+                        commands: activation_cmds,
+                        used_internal_flags: vec![],
+                    },
+                )),
+            })
             .expect("Completion channel intact");
     }
 
@@ -171,7 +175,7 @@ impl WorkflowFuture {
     fn handle_job(
         &mut self,
         variant: Option<Variant>,
-        outgoing_cmds: &mut Vec<workflow_command::Variant>,
+        outgoing_cmds: &mut Vec<WorkflowCommand>,
     ) -> Result<bool, Error> {
         if let Some(v) = variant {
             match v {
@@ -207,13 +211,13 @@ impl WorkflowFuture {
                 Variant::QueryWorkflow(q) => {
                     error!(
                         "Queries are not implemented in the Rust SDK. Got query '{}'",
-                        q.query_id
+                        q.query_type
                     );
                 }
-                Variant::CancelWorkflow(_) => {
+                Variant::CancelWorkflow(c) => {
                     // TODO: Cancel pending futures, etc
                     self.cancel_sender
-                        .send(true)
+                        .send(Some(c.reason))
                         .expect("Cancel rx not dropped");
                 }
                 Variant::SignalWorkflow(sig) => {
@@ -224,7 +228,7 @@ impl WorkflowFuture {
                             SigChanOrBuffer::Chan(chan) => {
                                 let _ = chan.send(dat);
                             }
-                            SigChanOrBuffer::Buffer(ref mut buf) => buf.push(dat),
+                            SigChanOrBuffer::Buffer(buf) => buf.push(dat),
                         },
                         Entry::Vacant(v) => {
                             v.insert(SigChanOrBuffer::Buffer(vec![dat]));
@@ -261,10 +265,13 @@ impl WorkflowFuture {
                         };
                         match val_res {
                             Ok(_) => {
-                                outgoing_cmds.push(update_response(
-                                    u.protocol_instance_id.clone(),
-                                    update_response::Response::Accepted(()),
-                                ));
+                                outgoing_cmds.push(
+                                    update_response(
+                                        u.protocol_instance_id.clone(),
+                                        update_response::Response::Accepted(()),
+                                    )
+                                    .into(),
+                                );
                                 let handler_fut = (impls.handler)(
                                     UpdateContext {
                                         wf_ctx: self.wf_ctx.clone(),
@@ -276,23 +283,47 @@ impl WorkflowFuture {
                                     .push((u.protocol_instance_id, handler_fut));
                             }
                             Err(e) => {
-                                outgoing_cmds.push(update_response(
-                                    u.protocol_instance_id,
-                                    update_response::Response::Rejected(e.into()),
-                                ));
+                                outgoing_cmds.push(
+                                    update_response(
+                                        u.protocol_instance_id,
+                                        update_response::Response::Rejected(e.into()),
+                                    )
+                                    .into(),
+                                );
                             }
                         }
                     } else {
-                        outgoing_cmds.push(update_response(
-                            u.protocol_instance_id,
-                            update_response::Response::Rejected(
-                                format!("No update handler registered for update name {}", u.name)
+                        outgoing_cmds.push(
+                            update_response(
+                                u.protocol_instance_id,
+                                update_response::Response::Rejected(
+                                    format!(
+                                        "No update handler registered for update name {}",
+                                        u.name
+                                    )
                                     .into(),
-                            ),
-                        ));
+                                ),
+                            )
+                            .into(),
+                        );
                     }
                 }
-
+                Variant::ResolveNexusOperationStart(attrs) => {
+                    self.unblock(UnblockEvent::NexusOperationStart(
+                        attrs.seq,
+                        Box::new(
+                            attrs
+                                .status
+                                .context("Nexus operation start must have status")?,
+                        ),
+                    ))?
+                }
+                Variant::ResolveNexusOperation(attrs) => {
+                    self.unblock(UnblockEvent::NexusOperationComplete(
+                        attrs.seq,
+                        Box::new(attrs.result.context("Nexus operation must have result")?),
+                    ))?
+                }
                 Variant::RemoveFromCache(_) => {
                     // TODO: Need to abort any user-spawned tasks, etc. See also cancel WF.
                     //   How best to do this in executor agnostic way? Is that possible?
@@ -314,13 +345,13 @@ impl Future for WorkflowFuture {
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         'activations: loop {
             // WF must always receive an activation first before responding with commands
-            let mut activation = match self.incoming_activations.poll_recv(cx) {
+            let activation = match self.incoming_activations.poll_recv(cx) {
                 Poll::Ready(a) => match a {
                     Some(act) => act,
                     None => {
                         return Poll::Ready(Err(anyhow!(
                             "Workflow future's activation channel was lost!"
-                        )))
+                        )));
                     }
                 },
                 Poll::Pending => return Poll::Pending,
@@ -342,18 +373,6 @@ impl Future for WorkflowFuture {
 
             let mut die_of_eviction_when_done = false;
             let mut activation_cmds = vec![];
-            // Assign initial state from start workflow job
-            if let Some(start_info) = activation.jobs.iter_mut().find_map(|j| {
-                if let Some(Variant::InitializeWorkflow(s)) = j.variant.as_mut() {
-                    Some(s)
-                } else {
-                    None
-                }
-            }) {
-                let mut wlock = self.wf_ctx.shared.write();
-                wlock.random_seed = start_info.randomness_seed;
-                wlock.search_attributes = start_info.search_attributes.take().unwrap_or_default();
-            };
             // Lame hack to avoid hitting "unregistered" update handlers in a situation where
             // the history has no commands until an update is accepted. Will go away w/ SDK redesign
             if activation
@@ -450,7 +469,7 @@ impl WorkflowFuture {
         &mut self,
         cx: &mut Context,
         run_id: &str,
-        activation_cmds: &mut Vec<workflow_command::Variant>,
+        activation_cmds: &mut Vec<WorkflowCommand>,
     ) -> Result<bool, Error> {
         // TODO: Make sure this is *actually* safe before un-prototyping rust sdk
         let mut res = match AssertUnwindSafe(&mut self.inner)
@@ -480,68 +499,61 @@ impl WorkflowFuture {
         while let Ok(cmd) = self.incoming_commands.try_recv() {
             match cmd {
                 RustWfCmd::Cancel(cancellable_id) => {
-                    match cancellable_id {
+                    let cmd_variant = match cancellable_id {
                         CancellableID::Timer(seq) => {
-                            activation_cmds
-                                .push(workflow_command::Variant::CancelTimer(CancelTimer { seq }));
                             self.unblock(UnblockEvent::Timer(seq, TimerResult::Cancelled))?;
                             // Re-poll wf future since a timer is now unblocked
                             res = self.inner.poll_unpin(cx);
+                            workflow_command::Variant::CancelTimer(CancelTimer { seq })
                         }
                         CancellableID::Activity(seq) => {
-                            activation_cmds.push(workflow_command::Variant::RequestCancelActivity(
+                            workflow_command::Variant::RequestCancelActivity(
                                 RequestCancelActivity { seq },
-                            ));
+                            )
                         }
                         CancellableID::LocalActivity(seq) => {
-                            activation_cmds.push(
-                                workflow_command::Variant::RequestCancelLocalActivity(
-                                    RequestCancelLocalActivity { seq },
-                                ),
-                            );
+                            workflow_command::Variant::RequestCancelLocalActivity(
+                                RequestCancelLocalActivity { seq },
+                            )
                         }
-                        CancellableID::ChildWorkflow(seq) => {
-                            activation_cmds.push(
-                                workflow_command::Variant::CancelChildWorkflowExecution(
-                                    CancelChildWorkflowExecution {
-                                        child_workflow_seq: seq,
-                                    },
-                                ),
-                            );
+                        CancellableID::ChildWorkflow { seqnum, reason } => {
+                            workflow_command::Variant::CancelChildWorkflowExecution(
+                                CancelChildWorkflowExecution {
+                                    child_workflow_seq: seqnum,
+                                    reason,
+                                },
+                            )
                         }
                         CancellableID::SignalExternalWorkflow(seq) => {
-                            activation_cmds.push(workflow_command::Variant::CancelSignalWorkflow(
-                                CancelSignalWorkflow { seq },
-                            ));
+                            workflow_command::Variant::CancelSignalWorkflow(CancelSignalWorkflow {
+                                seq,
+                            })
                         }
                         CancellableID::ExternalWorkflow {
                             seqnum,
                             execution,
-                            only_child,
-                        } => {
-                            activation_cmds.push(
-                                workflow_command::Variant::RequestCancelExternalWorkflowExecution(
-                                    RequestCancelExternalWorkflowExecution {
-                                        seq: seqnum,
-                                        target: Some(if only_child {
-                                            cancel_we::Target::ChildWorkflowId(
-                                                execution.workflow_id,
-                                            )
-                                        } else {
-                                            cancel_we::Target::WorkflowExecution(execution)
-                                        }),
-                                    },
-                                ),
-                            );
+                            reason,
+                        } => workflow_command::Variant::RequestCancelExternalWorkflowExecution(
+                            RequestCancelExternalWorkflowExecution {
+                                seq: seqnum,
+                                workflow_execution: Some(execution),
+                                reason,
+                            },
+                        ),
+                        CancellableID::NexusOp(seq) => {
+                            workflow_command::Variant::RequestCancelNexusOperation(
+                                RequestCancelNexusOperation { seq },
+                            )
                         }
-                    }
+                    };
+                    activation_cmds.push(cmd_variant.into());
                 }
-                RustWfCmd::NewCmd(cmd) => {
-                    activation_cmds.push(cmd.cmd.clone());
 
-                    let command_id = match cmd.cmd {
+                RustWfCmd::NewCmd(cmd) => {
+                    let command_id = match cmd.cmd.variant.as_ref().expect("command variant is set")
+                    {
                         workflow_command::Variant::StartTimer(StartTimer { seq, .. }) => {
-                            CommandID::Timer(seq)
+                            CommandID::Timer(*seq)
                         }
                         workflow_command::Variant::ScheduleActivity(ScheduleActivity {
                             seq,
@@ -549,14 +561,12 @@ impl WorkflowFuture {
                         })
                         | workflow_command::Variant::ScheduleLocalActivity(
                             ScheduleLocalActivity { seq, .. },
-                        ) => CommandID::Activity(seq),
+                        ) => CommandID::Activity(*seq),
                         workflow_command::Variant::SetPatchMarker(_) => {
                             panic!("Set patch marker should be a nonblocking command")
                         }
                         workflow_command::Variant::StartChildWorkflowExecution(req) => {
                             let seq = req.seq;
-                            // Save the start request to support cancellation later
-                            self.child_workflow_starts.insert(seq, req);
                             CommandID::ChildWorkflowStart(seq)
                         }
                         workflow_command::Variant::SignalExternalWorkflowExecution(req) => {
@@ -565,8 +575,13 @@ impl WorkflowFuture {
                         workflow_command::Variant::RequestCancelExternalWorkflowExecution(req) => {
                             CommandID::CancelExternal(req.seq)
                         }
+                        workflow_command::Variant::ScheduleNexusOperation(req) => {
+                            CommandID::NexusOpStart(req.seq)
+                        }
                         _ => unimplemented!("Command type not implemented"),
                     };
+                    activation_cmds.push(cmd.cmd);
+
                     self.command_status.insert(
                         command_id,
                         WFCommandFutInfo {
@@ -575,7 +590,7 @@ impl WorkflowFuture {
                     );
                 }
                 RustWfCmd::NewNonblockingCmd(cmd) => {
-                    activation_cmds.push(cmd);
+                    activation_cmds.push(cmd.into());
                 }
                 RustWfCmd::SubscribeChildWorkflowCompletion(sub) => {
                     self.command_status.insert(
@@ -604,42 +619,45 @@ impl WorkflowFuture {
                 RustWfCmd::RegisterUpdate(name, impls) => {
                     self.updates.insert(name, impls);
                 }
+                RustWfCmd::SubscribeNexusOperationCompletion { seq, unblocker } => {
+                    self.command_status.insert(
+                        CommandID::NexusOpComplete(seq),
+                        WFCommandFutInfo { unblocker },
+                    );
+                }
             }
         }
 
         if let Poll::Ready(res) = res {
             // TODO: Auto reply with cancel when cancelled (instead of normal exit value)
-            match res {
+            let cmd = match res {
                 Ok(exit_val) => match exit_val {
                     // TODO: Generic values
                     WfExitValue::Normal(result) => {
-                        activation_cmds.push(workflow_command::Variant::CompleteWorkflowExecution(
+                        workflow_command::Variant::CompleteWorkflowExecution(
                             CompleteWorkflowExecution {
                                 result: Some(result),
                             },
-                        ));
+                        )
                     }
-                    WfExitValue::ContinueAsNew(cmd) => activation_cmds.push((*cmd).into()),
-                    WfExitValue::Cancelled => {
-                        activation_cmds.push(workflow_command::Variant::CancelWorkflowExecution(
-                            CancelWorkflowExecution {},
-                        ));
+                    WfExitValue::ContinueAsNew(cmd) => {
+                        workflow_command::Variant::ContinueAsNewWorkflowExecution(*cmd)
                     }
+                    WfExitValue::Cancelled => workflow_command::Variant::CancelWorkflowExecution(
+                        CancelWorkflowExecution {},
+                    ),
                     WfExitValue::Evicted => {
                         panic!("Don't explicitly return this")
                     }
                 },
-                Err(e) => {
-                    activation_cmds.push(workflow_command::Variant::FailWorkflowExecution(
-                        FailWorkflowExecution {
-                            failure: Some(Failure {
-                                message: e.to_string(),
-                                ..Default::default()
-                            }),
-                        },
-                    ));
-                }
-            }
+                Err(e) => workflow_command::Variant::FailWorkflowExecution(FailWorkflowExecution {
+                    failure: Some(Failure {
+                        message: e.to_string(),
+                        ..Default::default()
+                    }),
+                }),
+            };
+            activation_cmds.push(cmd.into())
         }
         Ok(false)
     }
@@ -653,6 +671,8 @@ enum CommandID {
     ChildWorkflowComplete(u32),
     SignalExternal(u32),
     CancelExternal(u32),
+    NexusOpStart(u32),
+    NexusOpComplete(u32),
 }
 
 fn update_response(

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

@@ -1,7 +1,7 @@
 [package]
 name = "temporal-sdk-core-protos"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 authors = ["Spencer Judge <spencer@temporal.io>"]
 license-file = { workspace = true }
 description = "Protobuf definitions for Temporal SDKs Core/Lang interface"
@@ -19,13 +19,12 @@ anyhow = "1.0"
 base64 = "0.22"
 derive_more = { workspace = true }
 prost = { workspace = true }
-prost-types = { workspace = true }
 prost-wkt = "0.6"
 prost-wkt-types = "0.6"
-rand = { version = "0.8", optional = true }
+rand = { version = "0.9", optional = true }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-thiserror = "1.0"
+thiserror = { workspace = true }
 tonic = { workspace = true }
 uuid = { version = "1.1", features = ["v4"], optional = true }
 

package/sdk-core/sdk-core-protos/protos/api_cloud_upstream/VERSION

@@ -1 +1 @@
-2024-05-13-00
+2024-10-01-00

package/sdk-core/sdk-core-protos/protos/api_cloud_upstream/temporal/api/cloud/account/v1/message.proto

@@ -0,0 +1,46 @@
+syntax = "proto3";
+
+package temporal.api.cloud.account.v1;
+
+option go_package = "go.temporal.io/api/cloud/account/v1;account";
+option java_package = "io.temporal.api.cloud.account.v1";
+option java_multiple_files = true;
+option java_outer_classname = "MessageProto";
+option ruby_package = "Temporalio::Api::Cloud::Account::V1";
+option csharp_namespace = "Temporalio.Api.Cloud.Account.V1";
+
+import "temporal/api/cloud/resource/v1/message.proto";
+
+message MetricsSpec {
+    // The ca cert(s) in PEM format that clients connecting to the metrics endpoint can use for authentication.
+    // This must only be one value, but the CA can have a chain.
+    bytes accepted_client_ca = 2;
+}
+
+message AccountSpec {
+    // The metrics specification for this account.
+    // If not specified, metrics will not be enabled.
+    MetricsSpec metrics = 1;
+}
+
+message Metrics {
+    // The prometheus metrics endpoint uri.
+    // This is only populated when the metrics is enabled in the metrics specification.
+    string uri = 1;
+}
+
+message Account {
+    // The id of the account.
+    string id = 1;
+    // The account specification.
+    AccountSpec spec = 2;
+    // The current version of the account specification.
+    // The next update operation will have to include this version.
+    string resource_version = 3;
+    // The current state of the account.
+    temporal.api.cloud.resource.v1.ResourceState state = 4;
+    // The id of the async operation that is updating the account, if any.
+    string async_operation_id = 5;
+    // Information related to metrics.
+    Metrics metrics = 6;
+}