@temporalio/core-bridge 1.1.0 → 1.4.0

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

@@ -24,7 +24,7 @@ use crate::{
     telemetry::VecDisplayer,
     worker::{
         activities::{ActivitiesFromWFTsHandle, PermittedTqResp},
-        client::should_swallow_net_error,
+        client::WorkerClient,
         workflow::{
             managed_run::{ManagedRun, WorkflowManager},
             wft_poller::validate_wft,
@@ -32,7 +32,7 @@ use crate::{
         },
         LocalActRequest, LocalActivityResolution,
     },
-    MetricsContext, WorkerClientBag,
+    MetricsContext,
 };
 use futures::{stream::BoxStream, Stream, StreamExt};
 use std::{
@@ -58,6 +58,7 @@ use temporal_sdk_core_protos::{
     },
     temporal::api::{
         command::v1::{command::Attributes, Command as ProtoCommand, Command},
+        common::v1::{Memo, RetryPolicy, SearchAttributes},
         enums::v1::WorkflowTaskFailedCause,
         taskqueue::v1::StickyExecutionAttributes,
         workflowservice::v1::PollActivityTaskQueueResponse,
@@ -77,12 +78,14 @@ use tokio_util::sync::CancellationToken;
 use tracing::Span;
 
 pub(crate) const LEGACY_QUERY_ID: &str = "legacy_query";
+const MAX_EAGER_ACTIVITY_RESERVATIONS_PER_WORKFLOW_TASK: usize = 3;
 
 type Result<T, E = WFMachinesError> = result::Result<T, E>;
 type BoxedActivationStream = BoxStream<'static, Result<ActivationOrAuto, PollWfError>>;
 
 /// Centralizes all state related to workflows and workflow tasks
 pub(crate) struct Workflows {
+    task_queue: String,
     local_tx: UnboundedSender<LocalInput>,
     processing_task: tokio::sync::Mutex<Option<JoinHandle<()>>>,
     activation_stream: tokio::sync::Mutex<(
@@ -90,7 +93,7 @@ pub(crate) struct Workflows {
         // Used to indicate polling may begin
         Option<oneshot::Sender<()>>,
     )>,
-    client: Arc<WorkerClientBag>,
+    client: Arc<dyn WorkerClient>,
     /// Will be populated when this worker is using a cache and should complete WFTs with a sticky
     /// queue.
     sticky_attrs: Option<StickyExecutionAttributes>,
@@ -103,13 +106,15 @@ pub(super) struct WorkflowBasics {
     pub max_outstanding_wfts: usize,
     pub shutdown_token: CancellationToken,
     pub metrics: MetricsContext,
+    pub namespace: String,
+    pub task_queue: String,
 }
 
 impl Workflows {
     pub(super) fn new(
         basics: WorkflowBasics,
         sticky_attrs: Option<StickyExecutionAttributes>,
-        client: Arc<WorkerClientBag>,
+        client: Arc<dyn WorkerClient>,
         wft_stream: impl Stream<Item = Result<ValidPollWFTQResponse, tonic::Status>> + Send + 'static,
         local_activity_request_sink: impl Fn(Vec<LocalActRequest>) -> Vec<LocalActivityResolution>
             + Send
@@ -119,6 +124,7 @@ impl Workflows {
     ) -> Self {
         let (local_tx, local_rx) = unbounded_channel();
         let shutdown_tok = basics.shutdown_token.clone();
+        let task_queue = basics.task_queue.clone();
         let mut stream = WFStream::build(
             basics,
             wft_stream,
@@ -151,6 +157,7 @@ impl Workflows {
             }
         });
         Self {
+            task_queue,
             local_tx,
             processing_task: tokio::sync::Mutex::new(Some(processing_task)),
             activation_stream: tokio::sync::Mutex::new((
@@ -263,14 +270,14 @@ impl Workflows {
                         );
                         Ok(())
                     })
-                    .await?;
+                    .await;
                     true
                 }
                 ServerCommandsWithWorkflowInfo {
                     task_token,
                     action: ActivationAction::RespondLegacyQuery { result },
                 } => {
-                    self.respond_legacy_query(task_token, result).await?;
+                    self.respond_legacy_query(task_token, *result).await;
                     true
                 }
             },
@@ -282,13 +289,13 @@ impl Workflows {
                             .fail_workflow_task(tt, cause, failure.failure.map(Into::into))
                             .await
                     })
-                    .await?;
+                    .await;
                     true
                 }
                 FailedActivationWFTReport::ReportLegacyQueryFailure(task_token, failure) => {
                     warn!(run_id=%run_id, failure=?failure, "Failing legacy query request");
                     self.respond_legacy_query(task_token, legacy_query_failure(failure))
-                        .await?;
+                        .await;
                     true
                 }
             },
@@ -350,47 +357,34 @@ impl Workflows {
         self.send_local(msg);
     }
 
-    /// Handle server errors from either completing or failing a workflow task. Returns any errors
-    /// that can't be automatically handled.
-    async fn handle_wft_reporting_errs<T, Fut>(
-        &self,
-        run_id: &str,
-        completer: impl FnOnce() -> Fut,
-    ) -> Result<(), CompleteWfError>
+    /// Handle server errors from either completing or failing a workflow task. Un-handleable errors
+    /// trigger a workflow eviction and are logged.
+    async fn handle_wft_reporting_errs<T, Fut>(&self, run_id: &str, completer: impl FnOnce() -> Fut)
     where
         Fut: Future<Output = Result<T, tonic::Status>>,
     {
         let mut should_evict = None;
-        let res = match completer().await {
-            Err(err) => {
-                if should_swallow_net_error(&err) {
+        if let Err(err) = completer().await {
+            match err.code() {
+                // Silence unhandled command errors since the lang SDK cannot do anything
+                // about them besides poll again, which it will do anyway.
+                tonic::Code::InvalidArgument if err.message() == "UnhandledCommand" => {
+                    debug!(error = %err, run_id, "Unhandled command response when completing");
+                    should_evict = Some(EvictionReason::UnhandledCommand);
+                }
+                tonic::Code::NotFound => {
+                    warn!(error = %err, run_id, "Task not found when completing");
+                    should_evict = Some(EvictionReason::TaskNotFound);
+                }
+                _ => {
                     warn!(error= %err, "Network error while completing workflow activation");
                     should_evict = Some(EvictionReason::Fatal);
-                    Ok(())
-                } else {
-                    match err.code() {
-                        // Silence unhandled command errors since the lang SDK cannot do anything
-                        // about them besides poll again, which it will do anyway.
-                        tonic::Code::InvalidArgument if err.message() == "UnhandledCommand" => {
-                            debug!(error = %err, run_id, "Unhandled command response when completing");
-                            should_evict = Some(EvictionReason::UnhandledCommand);
-                            Ok(())
-                        }
-                        tonic::Code::NotFound => {
-                            warn!(error = %err, run_id, "Task not found when completing");
-                            should_evict = Some(EvictionReason::TaskNotFound);
-                            Ok(())
-                        }
-                        _ => Err(err),
-                    }
                 }
             }
-            _ => Ok(()),
-        };
+        }
         if let Some(reason) = should_evict {
             self.request_eviction(run_id, "Error reporting WFT to server", reason);
         }
-        res.map_err(Into::into)
     }
 
     /// Sends a message to the workflow processing stream. Returns true if the message was sent
@@ -471,10 +465,22 @@ impl Workflows {
                 {
                     // If request_eager_execution was already false, that means lang explicitly
                     // told us it didn't want to eagerly execute for some reason. So, we only
-                    // ever turn *off* eager execution if a slot is not available.
+                    // ever turn *off* eager execution if a slot is not available or the activity
+                    // is scheduled on a different task queue.
                     if attrs.request_eager_execution {
-                        if let Some(p) = at_handle.reserve_slot() {
-                            reserved.push(p);
+                        let same_task_queue = attrs
+                            .task_queue
+                            .as_ref()
+                            .map(|q| q.name == self.task_queue)
+                            .unwrap_or_default();
+                        if same_task_queue
+                            && reserved.len() < MAX_EAGER_ACTIVITY_RESERVATIONS_PER_WORKFLOW_TASK
+                        {
+                            if let Some(p) = at_handle.reserve_slot() {
+                                reserved.push(p);
+                            } else {
+                                attrs.request_eager_execution = false;
+                            }
                         } else {
                             attrs.request_eager_execution = false;
                         }
@@ -486,22 +492,15 @@ impl Workflows {
     }
 
     /// Wraps responding to legacy queries. Handles ignore-able failures.
-    async fn respond_legacy_query(
-        &self,
-        tt: TaskToken,
-        res: QueryResult,
-    ) -> Result<(), tonic::Status> {
+    async fn respond_legacy_query(&self, tt: TaskToken, res: QueryResult) {
         match self.client.respond_legacy_query(tt, res).await {
-            Ok(_) => Ok(()),
-            Err(e) if should_swallow_net_error(&e) => {
-                warn!(error= %e, "Network error while responding to legacy query");
-                Ok(())
-            }
+            Ok(_) => {}
             Err(e) if e.code() == tonic::Code::NotFound => {
                 warn!(error=?e, "Query not found when attempting to respond to it");
-                Ok(())
             }
-            Err(e) => Err(e),
+            Err(e) => {
+                warn!(error= %e, "Network error while responding to legacy query");
+            }
         }
     }
 }
@@ -794,7 +793,7 @@ pub(crate) enum ActivationAction {
         force_new_wft: bool,
     },
     /// We should respond to a legacy query request
-    RespondLegacyQuery { result: QueryResult },
+    RespondLegacyQuery { result: Box<QueryResult> },
 }
 
 #[derive(Debug, Eq, PartialEq, Hash)]
@@ -847,6 +846,7 @@ struct ActivationCompleteResult {
 }
 /// What needs to be done after calling [Workflows::activation_completed]
 #[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
 enum ActivationCompleteOutcome {
     /// The WFT must be reported as successful to the server using the contained information.
     ReportWFTSuccess(ServerCommandsWithWorkflowInfo),
@@ -917,6 +917,7 @@ fn validate_completion(
 }
 
 #[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
 enum ValidatedCompletion {
     Success {
         run_id: String,
@@ -944,6 +945,7 @@ struct RunAction {
     trace_span: Span,
 }
 #[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
 enum RunActions {
     NewIncomingWFT(NewIncomingWFT),
     ActivationCompletion(RunActivationCompletion),
@@ -984,6 +986,7 @@ struct RunUpdateResponse {
     span: Span,
 }
 #[derive(Debug, derive_more::Display)]
+#[allow(clippy::large_enum_variant)]
 enum RunUpdateResponseKind {
     Good(GoodRunUpdate),
     Fail(FailRunUpdate),
@@ -1068,7 +1071,7 @@ pub enum WFCommand {
     CancelWorkflow(CancelWorkflowExecution),
     SetPatchMarker(SetPatchMarker),
     AddChildWorkflow(StartChildWorkflowExecution),
-    CancelUnstartedChild(CancelUnstartedChildWorkflowExecution),
+    CancelChild(CancelChildWorkflowExecution),
     RequestCancelExternalWorkflow(RequestCancelExternalWorkflowExecution),
     SignalExternalWorkflow(SignalExternalWorkflowExecution),
     CancelSignalWorkflow(CancelSignalWorkflow),
@@ -1106,9 +1109,7 @@ impl TryFrom<WorkflowCommand> for WFCommand {
                 Ok(Self::SignalExternalWorkflow(s))
             }
             workflow_command::Variant::CancelSignalWorkflow(s) => Ok(Self::CancelSignalWorkflow(s)),
-            workflow_command::Variant::CancelUnstartedChildWorkflowExecution(s) => {
-                Ok(Self::CancelUnstartedChild(s))
-            }
+            workflow_command::Variant::CancelChildWorkflowExecution(s) => Ok(Self::CancelChild(s)),
             workflow_command::Variant::ScheduleLocalActivity(s) => Ok(Self::AddLocalActivity(s)),
             workflow_command::Variant::RequestCancelLocalActivity(s) => {
                 Ok(Self::RequestCancelLocalActivity(s))
@@ -1136,6 +1137,9 @@ enum CommandID {
 pub struct WorkflowStartedInfo {
     workflow_task_timeout: Option<Duration>,
     workflow_execution_timeout: Option<Duration>,
+    memo: Option<Memo>,
+    search_attrs: Option<SearchAttributes>,
+    retry_policy: Option<RetryPolicy>,
 }
 
 type LocalActivityRequestSink =

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

@@ -7,7 +7,7 @@ use crate::{
     MetricsContext,
 };
 use lru::LruCache;
-use std::time::Instant;
+use std::{num::NonZeroUsize, time::Instant};
 use tokio::sync::mpsc::UnboundedSender;
 
 pub(super) struct RunCache {
@@ -40,7 +40,9 @@ impl RunCache {
             max: max_cache_size,
             namespace,
             run_update_tx,
-            runs: LruCache::new(lru_size),
+            runs: LruCache::new(
+                NonZeroUsize::new(lru_size).expect("LRU size is guaranteed positive"),
+            ),
             local_activity_request_sink,
             metrics,
         }
@@ -132,7 +134,7 @@ impl RunCache {
         self.runs.iter().map(|(_, v)| v)
     }
     pub fn is_full(&self) -> bool {
-        self.runs.cap() == self.runs.len()
+        self.runs.cap().get() == self.runs.len()
     }
     pub fn len(&self) -> usize {
         self.runs.len()

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

@@ -6,7 +6,7 @@ use crate::{
         workflow::{history_update::NextPageToken, run_cache::RunCache, *},
         LocalActRequest, LocalActivityResolution, LEGACY_QUERY_ID,
     },
-    MetricsContext, WorkerClientBag,
+    MetricsContext,
 };
 use futures::{stream, stream::PollNext, Stream, StreamExt};
 use std::{collections::VecDeque, fmt::Debug, future, sync::Arc, time::Instant};
@@ -36,7 +36,7 @@ pub(crate) struct WFStream {
     buffered_polls_need_cache_slot: VecDeque<PermittedWFT>,
 
     /// Client for accessing server for history pagination etc.
-    client: Arc<WorkerClientBag>,
+    client: Arc<dyn WorkerClient>,
 
     /// Ensures we stay at or below this worker's maximum concurrent workflow task limit
     wft_semaphore: MeteredSemaphore,
@@ -118,7 +118,7 @@ impl WFStream {
         basics: WorkflowBasics,
         external_wfts: impl Stream<Item = Result<ValidPollWFTQResponse, tonic::Status>> + Send + 'static,
         local_rx: impl Stream<Item = LocalInput> + Send + 'static,
-        client: Arc<WorkerClientBag>,
+        client: Arc<dyn WorkerClient>,
         local_activity_request_sink: impl Fn(Vec<LocalActRequest>) -> Vec<LocalActivityResolution>
             + Send
             + Sync
@@ -157,7 +157,7 @@ impl WFStream {
             buffered_polls_need_cache_slot: Default::default(),
             runs: RunCache::new(
                 basics.max_cached_workflows,
-                client.namespace().to_string(),
+                basics.namespace.clone(),
                 run_update_tx,
                 Arc::new(local_activity_request_sink),
                 basics.metrics.clone(),
@@ -539,7 +539,9 @@ impl WFStream {
                 &run_id,
                 ActivationCompleteOutcome::ReportWFTSuccess(ServerCommandsWithWorkflowInfo {
                     task_token,
-                    action: ActivationAction::RespondLegacyQuery { result: qr },
+                    action: ActivationAction::RespondLegacyQuery {
+                        result: Box::new(qr),
+                    },
                 }),
                 resp_chan,
             );

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

@@ -17,10 +17,10 @@ anyhow = "1.0"
 async-trait = "0.1"
 derive_builder = "0.11"
 log = "0.4"
-opentelemetry = "0.17"
-prost-types = "0.9"
+opentelemetry = "0.18"
+prost-types = "0.11"
 thiserror = "1.0"
-tonic = "0.6"
+tonic = "0.8"
 
 [dependencies.temporal-sdk-core-protos]
 path = "../sdk-core-protos"

package/sdk-core/core-api/src/errors.rs

@@ -1,6 +1,6 @@
 //! Error types exposed by public APIs
 
-use prost_types::TimestampOutOfSystemRangeError;
+use prost_types::TimestampError;
 use temporal_sdk_core_protos::coresdk::{
     activity_result::ActivityExecutionResult,
     workflow_activation::remove_from_cache::EvictionReason,
@@ -50,10 +50,6 @@ pub enum CompleteWfError {
         /// The run associated with the completion
         run_id: String,
     },
-    /// Unhandled error when calling the temporal server. Core will attempt to retry any non-fatal
-    /// errors, so lang should consider this fatal.
-    #[error("Unhandled grpc error when completing workflow task: {0:?}")]
-    TonicError(#[from] tonic::Status),
 }
 
 /// Errors thrown by [crate::Worker::complete_activity_task]
@@ -67,10 +63,6 @@ pub enum CompleteActivityError {
         /// The completion, which may not be included to avoid unnecessary copies.
         completion: Option<ActivityExecutionResult>,
     },
-    /// Unhandled error when calling the temporal server. Core will attempt to retry any non-fatal
-    /// errors, so lang should consider this fatal.
-    #[error("Unhandled grpc error when completing activity: {0:?}")]
-    TonicError(#[from] tonic::Status),
 }
 
 /// Errors thrown inside of workflow machines
@@ -96,8 +88,8 @@ impl WFMachinesError {
     }
 }
 
-impl From<TimestampOutOfSystemRangeError> for WFMachinesError {
-    fn from(_: TimestampOutOfSystemRangeError) -> Self {
+impl From<TimestampError> for WFMachinesError {
+    fn from(_: TimestampError) -> Self {
         Self::Fatal("Could not decode timestamp".to_string())
     }
 }

package/sdk-core/core-api/src/worker.rs

@@ -88,6 +88,13 @@ pub struct WorkerConfig {
     /// the options to fail.
     #[builder(default)]
     pub max_worker_activities_per_second: Option<f64>,
+
+    /// # UNDER DEVELOPMENT
+    /// If set to true this worker will opt-in to the whole-worker versioning feature.
+    /// `worker_build_id` will be used as the version.
+    /// todo: link to feature docs
+    #[builder(default = "false")]
+    pub use_worker_versioning: bool,
 }
 
 impl WorkerConfig {

package/sdk-core/protos/api_upstream/.buildkite/Dockerfile

@@ -1,2 +1,2 @@
-FROM temporalio/base-ci-builder:1.0.0
+FROM temporalio/base-ci-builder:1.5.0
 WORKDIR /temporal

package/sdk-core/protos/api_upstream/.github/CODEOWNERS

@@ -1,4 +1,4 @@
 # Syntax is here:
 # https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/about-code-owners#codeowners-syntax
 
-*                @temporalio/core
+*                @temporalio/server @temporalio/sdk

package/sdk-core/protos/api_upstream/.github/PULL_REQUEST_TEMPLATE.md

@@ -6,10 +6,6 @@
 **Why?**
 
 
-<!-- How have you verified this change? Tested locally? Added a unit test? Checked in staging env? -->
-**How did you test it?**
-
-
-<!-- Assuming the worst case, what can be broken when deploying this change to production? -->
-**Potential risks**
+<!-- Are there any breaking changes on binary or code level? -->
+**Breaking changes**
 

package/sdk-core/protos/api_upstream/.github/workflows/trigger-api-go-update.yml

@@ -0,0 +1,29 @@
+name: 'Trigger api-go Update'
+
+on:
+  push:
+    branches:
+      - master
+  workflow_dispatch:
+
+jobs:
+  notify:
+    name: 'Trigger api-go update'
+    runs-on: ubuntu-latest
+
+    defaults:
+      run:
+        shell: bash
+
+    steps:
+      - name: Dispatch api-go Github Action
+        env:
+          PAT: ${{ secrets.COMMANDER_DATA_TOKEN }}
+          PARENT_REPO: temporalio/api-go
+          PARENT_BRANCH: ${{ toJSON('master') }}
+          WORKFLOW_ID: update-proto.yml
+          COMMIT_AUTHOR: ${{ toJSON(github.event.head_commit.author.name) }}
+          COMMIT_AUTHOR_EMAIL: ${{ toJSON(github.event.head_commit.author.email) }}
+          COMMIT_MESSAGE: ${{ toJSON(github.event.head_commit.message) }}
+        run: |
+          curl -fL -X POST -H "Accept: application/vnd.github.v3+json" -H "Authorization: token ${{ env.PAT }}" https://api.github.com/repos/${{ env.PARENT_REPO }}/actions/workflows/${{ env.WORKFLOW_ID }}/dispatches -d '{"ref":'"$PARENT_BRANCH"', "inputs":{"commit_author":'"$COMMIT_AUTHOR"', "commit_author_email":'"$COMMIT_AUTHOR_EMAIL"', "commit_message":'"$COMMIT_MESSAGE"'}}'

package/sdk-core/protos/api_upstream/Makefile

@@ -33,11 +33,11 @@ grpc: buf-lint api-linter buf-breaking gogo-grpc fix-path
 
 go-grpc: clean $(PROTO_OUT)
 	printf $(COLOR) "Compile for go-gRPC..."
-	$(foreach PROTO_DIR,$(PROTO_DIRS),protoc $(PROTO_IMPORTS) --go_out=plugins=grpc,paths=source_relative:$(PROTO_OUT) $(PROTO_DIR)*.proto;)
+	$(foreach PROTO_DIR,$(PROTO_DIRS),protoc --fatal_warnings $(PROTO_IMPORTS) --go_out=plugins=grpc,paths=source_relative:$(PROTO_OUT) $(PROTO_DIR)*.proto;)
 
 gogo-grpc: clean $(PROTO_OUT)
 	printf $(COLOR) "Compile for gogo-gRPC..."
-	$(foreach PROTO_DIR,$(PROTO_DIRS),protoc $(PROTO_IMPORTS) --gogoslick_out=Mgoogle/protobuf/wrappers.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/duration.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/descriptor.proto=github.com/golang/protobuf/protoc-gen-go/descriptor,Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types,plugins=grpc,paths=source_relative:$(PROTO_OUT) $(PROTO_DIR)*.proto;)
+	$(foreach PROTO_DIR,$(PROTO_DIRS),protoc --fatal_warnings $(PROTO_IMPORTS) --gogoslick_out=Mgoogle/protobuf/wrappers.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/duration.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/descriptor.proto=github.com/golang/protobuf/protoc-gen-go/descriptor,Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types,plugins=grpc,paths=source_relative:$(PROTO_OUT) $(PROTO_DIR)*.proto;)
 
 fix-path:
 	mv -f $(PROTO_OUT)/temporal/api/* $(PROTO_OUT) && rm -rf $(PROTO_OUT)/temporal

package/sdk-core/protos/api_upstream/buf.yaml

@@ -2,6 +2,7 @@ version: v1
 breaking:
   ignore:
     - temporal/api/schedule/v1
+    - temporal/api/update/v1
   use:
     - PACKAGE
 lint:

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

@@ -0,0 +1,86 @@
+// 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.batch.v1;
+
+option go_package = "go.temporal.io/api/batch/v1;batch";
+option java_package = "io.temporal.api.batch.v1";
+option java_multiple_files = true;
+option java_outer_classname = "MessageProto";
+option ruby_package = "Temporal::Api::Batch::V1";
+option csharp_namespace = "Temporal.Api.Batch.V1";
+
+import "dependencies/gogoproto/gogo.proto";
+import "google/protobuf/timestamp.proto";
+
+
+import "temporal/api/common/v1/message.proto";
+import "temporal/api/enums/v1/batch_operation.proto";
+
+message BatchOperationInfo {
+  // Batch job ID
+  string job_id = 1;
+  // Batch operation state
+  temporal.api.enums.v1.BatchOperationState state = 2;
+  // Batch operation start time
+  google.protobuf.Timestamp start_time = 3 [(gogoproto.stdtime) = true];
+  // Batch operation close time
+  google.protobuf.Timestamp close_time = 4 [(gogoproto.stdtime) = true];
+}
+
+// BatchOperationTermination sends terminate requests to batch workflows.
+// Keep the parameter in sync with temporal.api.workflowservice.v1.TerminateWorkflowExecutionRequest.
+// Ignore first_execution_run_id because this is used for single workflow operation.
+message BatchOperationTermination {
+  // Reason of terminate workflows
+  string reason = 1;
+  // Serialized value(s) to provide to the termination event
+  temporal.api.common.v1.Payloads details = 2;
+  // The identity of the worker/client
+  string identity = 3;
+}
+
+// BatchOperationSignal sends signals to batch workflows.
+// Keep the parameter in sync with temporal.api.workflowservice.v1.SignalWorkflowExecutionRequest.
+message BatchOperationSignal {
+  // The workflow author-defined name of the signal to send to the workflow
+  string signal = 1;
+  // Serialized value(s) to provide with the signal
+  temporal.api.common.v1.Payloads input = 2;
+  // Headers that are passed with the signal to the processing workflow.
+  // These can include things like auth or tracing tokens.
+  temporal.api.common.v1.Header header = 3;
+  // The identity of the worker/client
+  string identity = 4;
+}
+
+// BatchOperationCancellation sends cancel requests to batch workflows.
+// Keep the parameter in sync with temporal.api.workflowservice.v1.RequestCancelWorkflowExecutionRequest.
+// Ignore first_execution_run_id because this is used for single workflow operation.
+message BatchOperationCancellation {
+  // Reason of cancel workflows
+  string reason = 1;
+  // The identity of the worker/client
+  string identity = 2;
+}

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

@@ -37,6 +37,7 @@ import "dependencies/gogoproto/gogo.proto";
 
 import "temporal/api/enums/v1/workflow.proto";
 import "temporal/api/enums/v1/command_type.proto";
+import "temporal/api/enums/v1/update.proto";
 import "temporal/api/common/v1/message.proto";
 import "temporal/api/failure/v1/message.proto";
 import "temporal/api/taskqueue/v1/message.proto";
@@ -213,6 +214,29 @@ message StartChildWorkflowExecutionCommandAttributes {
     temporal.api.common.v1.SearchAttributes search_attributes = 16;
 }
 
+message AcceptWorkflowUpdateCommandAttributes {
+    // A unique identifier for an update within a given workflow context
+    string update_id = 1;
+}
+
+message CompleteWorkflowUpdateCommandAttributes {
+    // A unique identifier for an update within a given workflow context
+    string update_id = 1;
+
+    // Whether the server should attempt to bypass making this update rejection
+    // durable in history. This field is only consulted when the result field
+    // indicates failure. Leaving this field in its default state (i.e.
+    // UPDATE_WORKFLOW_REJECTION_DURABILITY_PREFERENCE_UNSPECIFIED) will result
+    // in making the rejection durable.
+    temporal.api.enums.v1.WorkflowUpdateDurabilityPreference durability_preference = 2;
+
+    // The success or failure output of the update
+    oneof result {
+        temporal.api.common.v1.Payloads success = 3;
+        temporal.api.failure.v1.Failure failure = 4;
+    }
+}
+
 message Command {
     temporal.api.enums.v1.CommandType command_type = 1;
     oneof attributes {
@@ -229,5 +253,7 @@ message Command {
         StartChildWorkflowExecutionCommandAttributes start_child_workflow_execution_command_attributes = 12;
         SignalExternalWorkflowExecutionCommandAttributes signal_external_workflow_execution_command_attributes = 13;
         UpsertWorkflowSearchAttributesCommandAttributes upsert_workflow_search_attributes_command_attributes = 14;
+        AcceptWorkflowUpdateCommandAttributes accept_workflow_update_command_attributes = 15;
+        CompleteWorkflowUpdateCommandAttributes complete_workflow_update_command_attributes = 16;
     }
 }