@temporalio/core-bridge 0.17.2 → 0.18.0

package/sdk-core/protos/local/temporal/sdk/core/bridge/bridge.proto

@@ -0,0 +1,205 @@
+syntax = "proto3";
+
+package coresdk.bridge;
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/wrappers.proto";
+import "temporal/sdk/core/core_interface.proto";
+import "temporal/sdk/core/activity_task/activity_task.proto";
+import "temporal/sdk/core/workflow_activation/workflow_activation.proto";
+import "temporal/sdk/core/workflow_completion/workflow_completion.proto";
+
+enum LogLevel {
+  LOG_LEVEL_UNSPECIFIED = 0;
+  OFF = 1;
+  ERROR = 2;
+  WARN = 3;
+  INFO = 4;
+  DEBUG = 5;
+  TRACE = 6;
+}
+
+message InitRequest {
+  GatewayOptions gateway_options = 1;
+  TelemetryOptions telemetry_options = 2;
+
+  message GatewayOptions {
+    string target_url = 1;
+    string namespace = 2;
+    string client_name = 3;
+    string client_version = 4;
+    map<string, string> static_headers = 5;
+    string identity = 6;
+    string worker_binary_id = 7;
+    TlsConfig tls_config = 8;
+    RetryConfig retry_config = 9;
+  }
+
+  message TlsConfig {
+    bytes server_root_ca_cert = 1;
+    string domain = 2;
+    bytes client_cert = 3;
+    bytes client_private_key = 4;
+  }
+
+  message RetryConfig {
+    google.protobuf.Duration initial_interval = 1;
+    google.protobuf.DoubleValue randomization_factor = 2;
+    google.protobuf.DoubleValue multiplier = 3;
+    google.protobuf.Duration max_interval = 4;
+    google.protobuf.Duration max_elapsed_time = 5;
+    google.protobuf.UInt32Value max_retries = 6;
+  }
+
+  message TelemetryOptions {
+    string otel_collector_url = 1;
+    string tracing_filter = 2;
+    LogLevel log_forwarding_level = 3;
+    string prometheus_export_bind_address = 4;
+  }
+}
+
+message InitResponse {
+  Error error = 1;
+
+  message Error {
+    string message = 1;
+  }
+}
+
+message RegisterWorkerRequest {
+  string task_queue = 1;
+  google.protobuf.UInt32Value max_cached_workflows = 2;
+  google.protobuf.UInt32Value max_outstanding_workflow_tasks = 3;
+  google.protobuf.UInt32Value max_outstanding_activities = 4;
+  google.protobuf.UInt32Value max_outstanding_local_activities = 5;
+  google.protobuf.UInt32Value max_concurrent_wft_polls = 6;
+  google.protobuf.FloatValue nonsticky_to_sticky_poll_ratio = 7;
+  google.protobuf.UInt32Value max_concurrent_at_polls = 8;
+  bool no_remote_activities = 9;
+  google.protobuf.Duration sticky_queue_schedule_to_start_timeout = 10;
+  google.protobuf.Duration max_heartbeat_throttle_interval = 11;
+  google.protobuf.Duration default_heartbeat_throttle_interval = 12;
+}
+
+message RegisterWorkerResponse {
+  Error error = 1;
+
+  message Error {
+    string message = 1;
+    bool worker_already_registered = 2;
+  }
+}
+
+message PollWorkflowActivationRequest {
+  string task_queue = 1;
+}
+
+message PollWorkflowActivationResponse {
+  oneof response {
+    coresdk.workflow_activation.WorkflowActivation activation = 1;
+    Error error = 2;
+  }
+
+  message Error {
+    string message = 1;
+    bool shutdown = 2;
+  }
+}
+
+message PollActivityTaskRequest {
+  string task_queue = 1;
+}
+
+message PollActivityTaskResponse {
+  oneof response {
+    coresdk.activity_task.ActivityTask task = 1;
+    Error error = 2;
+  }
+
+  message Error {
+    string message = 1;
+    bool shutdown = 2;
+  }
+}
+
+message CompleteWorkflowActivationRequest {
+  coresdk.workflow_completion.WorkflowActivationCompletion completion = 1;
+}
+
+message CompleteWorkflowActivationResponse {
+  Error error = 1;
+
+  message Error {
+    string message = 1;
+  }
+}
+
+message CompleteActivityTaskRequest {
+  coresdk.ActivityTaskCompletion completion = 1;
+}
+
+message CompleteActivityTaskResponse {
+  Error error = 1;
+
+  message Error {
+    string message = 1;
+  }
+}
+
+message RecordActivityHeartbeatRequest {
+  coresdk.ActivityHeartbeat heartbeat = 1;
+}
+
+message RecordActivityHeartbeatResponse {
+  Error error = 1;
+
+  message Error {
+    string message = 1;
+  }
+}
+
+message RequestWorkflowEvictionRequest {
+  string task_queue = 1;
+  string run_id = 2;
+}
+
+message RequestWorkflowEvictionResponse {
+  Error error = 1;
+
+  message Error {
+    string message = 1;
+  }
+}
+
+message ShutdownRequest {
+}
+
+message ShutdownResponse {
+}
+
+message ShutdownWorkerRequest {
+  string task_queue = 1;
+}
+
+message ShutdownWorkerResponse {
+  Error error = 1;
+
+  message Error {
+    string message = 1;
+  }
+}
+
+message FetchBufferedLogsRequest {
+}
+
+message FetchBufferedLogsResponse {
+  repeated LogEntry entries = 1;
+
+  message LogEntry {
+    string message = 1;
+    google.protobuf.Timestamp timestamp = 2;
+    LogLevel level = 3;
+  }
+}

package/sdk-core/protos/local/temporal/sdk/core/bridge/service.proto

@@ -0,0 +1,61 @@
+syntax = "proto3";
+
+package coresdk.bridge;
+
+import "temporal/sdk/core/bridge/bridge.proto";
+
+service Bridge {
+  // Starts an isolated core instance unique to this stream that will
+  // automatically be shutdown on completion of the stream. The caller must
+  // provide the first message and it must be an "init". No other calls can be
+  // made until the init response has been received by the client.
+  //
+  // Every request message will have a single correlated response message,
+  // though not necessarily in a particular order or timeframe.
+  //
+  // There is no requst for "shutdown", because it is implied on stream
+  // completion.
+  //
+  // The stream approach is chosen because core is inherently stateful while
+  // gRPC unary RPCs are not. Upon abnormal stream close, the caller should
+  // reattempt, performing the init again.
+  rpc Stream(stream StreamRequest) returns (stream StreamResponse);
+}
+
+message StreamRequest {
+  // The ID sent in the response. This is not technically required nor must it
+  // be unique if the caller, say, knows they only have one message outstanding
+  // of a certain type. However, it is recommended that this always be present
+  // and unique to avoid confusion.
+  string id = 1;
+
+  oneof request {
+    InitRequest init = 2;
+    RegisterWorkerRequest register_worker = 3;
+    PollWorkflowActivationRequest poll_workflow_activation = 4;
+    PollActivityTaskRequest poll_activity_task = 5;
+    CompleteWorkflowActivationRequest complete_workflow_activation = 6;
+    CompleteActivityTaskRequest complete_activity_task = 7;
+    RecordActivityHeartbeatRequest record_activity_heartbeat = 8;
+    RequestWorkflowEvictionRequest request_workflow_eviction = 9;
+    ShutdownWorkerRequest shutdown_worker = 10;
+    FetchBufferedLogsRequest fetch_buffered_logs = 11;
+  }
+}
+
+message StreamResponse {
+  string request_id = 1;
+
+  oneof response {
+    InitResponse init = 2;
+    RegisterWorkerResponse register_worker = 3;
+    PollWorkflowActivationResponse poll_workflow_activation = 4;
+    PollActivityTaskResponse poll_activity_task = 5;
+    CompleteWorkflowActivationResponse complete_workflow_activation = 6;
+    CompleteActivityTaskResponse complete_activity_task = 7;
+    RecordActivityHeartbeatResponse record_activity_heartbeat = 8;
+    RequestWorkflowEvictionResponse request_workflow_eviction = 9;
+    ShutdownWorkerResponse shutdown_worker = 10;
+    FetchBufferedLogsResponse fetch_buffered_logs = 11;
+  }
+}

package/sdk-core/protos/local/{child_workflow.proto → temporal/sdk/core/child_workflow/child_workflow.proto}

@@ -2,8 +2,8 @@ syntax = "proto3";
 
 package coresdk.child_workflow;
 
-import "common.proto";
 import "temporal/api/failure/v1/message.proto";
+import "temporal/sdk/core/common/common.proto";
 
 /**
  * Used by core to resolve child workflow executions.

package/sdk-core/protos/local/{common.proto → temporal/sdk/core/common/common.proto}

@@ -36,20 +36,22 @@ message NamespacedWorkflowExecution {
 
 
 // Defines how an activity or workflow should be retried in the event of failure, timeout, etc.
+// Defaults may differ depending on what this is being used for. See containing messages.
 message RetryPolicy {
     // Interval of the first retry. If backoff_coefficient is 1.0 then it is used for all
-    // retries.
+    // retries. If this is not specified, there will be *no retrying*. Lang SDKs should require
+    // this to be set.
     google.protobuf.Duration initial_interval = 1;
     // Coefficient used to calculate the next retry interval. The next retry interval is previous
     // interval multiplied by the coefficient. Must be 1 or larger.
     double backoff_coefficient = 2;
     // Maximum interval between retries. Exponential backoff leads to interval increase. This value
-    // caps that interval. Default is 100x of the initial interval.
+    // caps that interval.
     google.protobuf.Duration maximum_interval = 3;
     // Maximum number of attempts. When exceeded, retrying will stop. 1 disables retries. 0 means
     // unlimited retries (until the activity or workflow's total timeout is reached).
     int32 maximum_attempts = 4;
-    // If a stringified error matches something in this list, retries will cease.
+    // If a stringified error type matches something in this list, retries will cease.
     repeated string non_retryable_error_types = 5;
 }
 

package/sdk-core/protos/local/{core_interface.proto → temporal/sdk/core/core_interface.proto}

@@ -2,19 +2,19 @@ syntax = "proto3";
 
 package coresdk;
 
-import "activity_result.proto";
-import "activity_task.proto";
-import "common.proto";
-import "workflow_activation.proto";
-import "workflow_commands.proto";
-import "workflow_completion.proto";
-
-// Note: Intellij will think these imports don't work because of the slightly odd nature of
+// Note: Intellij will think the Google imports don't work because of the slightly odd nature of
 // the include paths. You can make it work by going to the "Protobuf Support" settings section
 // and adding the "api_upstream" subdir as an include path.
-import "google/protobuf/timestamp.proto";
 import "google/protobuf/duration.proto";
 import "google/protobuf/empty.proto";
+import "google/protobuf/timestamp.proto";
+import "temporal/sdk/core/activity_result/activity_result.proto";
+import "temporal/sdk/core/activity_task/activity_task.proto";
+import "temporal/sdk/core/common/common.proto";
+import "temporal/sdk/core/external_data/external_data.proto";
+import "temporal/sdk/core/workflow_activation/workflow_activation.proto";
+import "temporal/sdk/core/workflow_commands/workflow_commands.proto";
+import "temporal/sdk/core/workflow_completion/workflow_completion.proto";
 
 // A request as given to `record_activity_heartbeat`
 message ActivityHeartbeat {
@@ -29,5 +29,5 @@ message ActivityTaskCompletion {
     bytes task_token = 1;
     // The task queue / worker this task is associated with
     string task_queue = 2;
-    activity_result.ActivityResult result = 3;
+    activity_result.ActivityExecutionResult result = 3;
 }

package/sdk-core/protos/local/temporal/sdk/core/external_data/external_data.proto

@@ -0,0 +1,30 @@
+syntax = "proto3";
+
+package coresdk.external_data;
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+
+// This file defines data that Core might write externally. The first motivating case being
+// storing data in markers in event history. Defining such data as protos provides an easy way
+// for consumers which would like to just depend on the proto package to make sense of marker data.
+
+message LocalActivityMarkerData {
+  uint32 seq = 1;
+  // The number of attempts at execution before we recorded this result. Typically starts at 1,
+  // but it is possible to start at a higher number when backing off using a timer.
+  uint32 attempt = 2;
+  string activity_id = 3;
+  string activity_type = 4;
+  // You can think of this as "perceived completion time". It is the time the local activity thought
+  // it was when it completed. Which could be different from wall-clock time because of workflow
+  // replay. It's the WFT start time + the LA's runtime
+  google.protobuf.Timestamp complete_time = 5;
+  // If set, this local activity conceptually is retrying after the specified backoff.
+  // Implementation wise, they are really two different LA machines, but with the same type & input.
+  // The retry starts with an attempt number > 1.
+  google.protobuf.Duration backoff = 6;
+  // The time the LA was originally scheduled (wall clock time). This is used to track
+  // schedule-to-close timeouts when timer-based backoffs are used
+  google.protobuf.Timestamp original_schedule_time = 7;
+}

package/sdk-core/protos/local/{workflow_activation.proto → temporal/sdk/core/workflow_activation/workflow_activation.proto}

@@ -6,16 +6,15 @@ syntax = "proto3";
  */
 package coresdk.workflow_activation;
 
-import "common.proto";
-import "activity_result.proto";
-import "child_workflow.proto";
-
-import "temporal/api/failure/v1/message.proto";
 import "google/protobuf/timestamp.proto";
+import "temporal/api/failure/v1/message.proto";
+import "temporal/sdk/core/activity_result/activity_result.proto";
+import "temporal/sdk/core/child_workflow/child_workflow.proto";
+import "temporal/sdk/core/common/common.proto";
 
 /// An instruction to the lang sdk to run some workflow code, whether for the first time or from
 /// a cached state.
-message WFActivation {
+message WorkflowActivation {
     /// The id of the currently active run of the workflow. Also used as a cache key. There may
     /// only ever be one active workflow task (and hence activation) of a run at one time.
     string run_id = 1;
@@ -24,10 +23,10 @@ message WFActivation {
     /// Whether or not the activation is replaying past events
     bool is_replaying = 3;
     /// The things to do upon activating the workflow
-    repeated WFActivationJob jobs = 4;
+    repeated WorkflowActivationJob jobs = 4;
 }
 
-message WFActivationJob {
+message WorkflowActivationJob {
     oneof variant {
         /// Begin a workflow for the first time
         StartWorkflow start_workflow = 1;
@@ -55,7 +54,7 @@ message WFActivationJob {
         ResolveSignalExternalWorkflow resolve_signal_external_workflow = 12;
         /// An attempt to cancel an external workflow resolved
         ResolveRequestCancelExternalWorkflow resolve_request_cancel_external_workflow = 13;
-        /// Remove the workflow identified by the [WFActivation] containing this job from the cache
+        /// Remove the workflow identified by the [WorkflowActivation] containing this job from the cache
         /// after performing the activation.
         ///
         /// If other job variant are present in the list, this variant will be the last job in the
@@ -92,7 +91,7 @@ message FireTimer {
 message ResolveActivity {
     /// Sequence number as provided by lang in the corresponding ScheduleActivity command
     uint32 seq = 1;
-    activity_result.ActivityResult result = 2;
+    activity_result.ActivityResolution result = 2;
 }
 
 /// Notify a workflow that a start child workflow execution request has succeeded, failed or was
@@ -188,5 +187,30 @@ message ResolveRequestCancelExternalWorkflow {
 }
 
 message RemoveFromCache {
-    string reason = 1;
+    string message = 1;
+
+    enum EvictionReason {
+        UNSPECIFIED = 0;
+        // Workflow cache is full
+        CACHE_FULL = 1;
+        // Workflow received a partial task but was not in the cache. Typically it won't be in the
+        // lang cache either at this point, but we send an eviction to be sure.
+        CACHE_MISS = 2;
+        // The workflow produced results inconsistent with history.
+        NONDETERMINISM = 3;
+        // The lang side completed the workflow activation with a failure.
+        LANG_FAIL = 4;
+        // The lang side explicitly requested this workflow be evicted.
+        LANG_REQUESTED = 5;
+        // The workflow task we tried to respond to didn't exist. The workflow might have already
+        // finished, or the WFT timed out but we didn't learn about that yet.
+        TASK_NOT_FOUND = 6;
+        // There was new work that must be handled while we attempted to complete the WFT. Ex:
+        // a new signal came in while trying to complete the workflow.
+        UNHANDLED_COMMAND = 7;
+        // There was some fatal error processing the workflow, typically an internal error, but
+        // can also happen if then network drops out while paginating. Check message string.
+        FATAL = 8;
+    }
+    EvictionReason reason = 2;
 }

package/sdk-core/protos/local/{workflow_commands.proto → temporal/sdk/core/workflow_commands/workflow_commands.proto}

@@ -7,10 +7,11 @@ syntax = "proto3";
  */
 package coresdk.workflow_commands;
 
-import "common.proto";
-import "child_workflow.proto";
 import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
 import "temporal/api/failure/v1/message.proto";
+import "temporal/sdk/core/child_workflow/child_workflow.proto";
+import "temporal/sdk/core/common/common.proto";
 
 message WorkflowCommand {
     oneof variant {
@@ -29,6 +30,8 @@ message WorkflowCommand {
         RequestCancelExternalWorkflowExecution request_cancel_external_workflow_execution = 13;
         SignalExternalWorkflowExecution signal_external_workflow_execution = 14;
         CancelSignalWorkflow cancel_signal_workflow = 15;
+        ScheduleLocalActivity schedule_local_activity = 16;
+        RequestCancelLocalActivity request_cancel_local_activity = 17;
 
         // To be added as/if needed:
         //  UpsertWorkflowSearchAttributes upsert_workflow_search_attributes_command_attributes = 14;
@@ -72,9 +75,52 @@ message ScheduleActivity {
     google.protobuf.Duration heartbeat_timeout = 11;
     /// Activities are provided by a default retry policy controlled through the service dynamic
     /// configuration. Retries are happening up to schedule_to_close_timeout. To disable retries set
-    /// retry_policy.maximum_attempts to 2.
+    /// retry_policy.maximum_attempts to 1.
     common.RetryPolicy retry_policy = 12;
-    /// Defines behaviour of the underlying workflow when activity cancellation has been requested.
+    /// Defines how the workflow will wait (or not) for cancellation of the activity to be confirmed
+    ActivityCancellationType cancellation_type = 13;
+}
+
+message ScheduleLocalActivity {
+    /// Lang's incremental sequence number, used as the operation identifier
+    uint32 seq = 1;
+    string activity_id = 2;
+    string activity_type = 3;
+    /// Local activities can start with a non-1 attempt, if lang has been told to backoff using
+    /// a timer before retrying. It should pass the attempt number from a `DoBackoff` activity
+    /// resolution.
+    uint32 attempt = 4;
+    /// If this local activity is a retry (as per the attempt field) this needs to be the original
+    /// scheduling time (as provided in `DoBackoff`)
+    google.protobuf.Timestamp original_schedule_time = 5;
+    map<string, common.Payload> header_fields = 6;
+    /// Arguments/input to the activity.
+    repeated common.Payload arguments = 7;
+    /// Indicates how long the caller is willing to wait for local activity completion. Limits how
+    /// long retries will be attempted. When not specified defaults to the workflow execution
+    /// timeout (which may be unset).
+    google.protobuf.Duration schedule_to_close_timeout = 8;
+    /// Limits time the local activity can idle internally before being executed. That can happen if
+    /// the worker is currently at max concurrent local activity executions. This timeout is always
+    /// non retryable as all a retry would achieve is to put it back into the same queue. Defaults
+    /// to `schedule_to_close_timeout` if not specified and that is set. Must be <=
+    /// `schedule_to_close_timeout` when set, otherwise, it will be clamped down.
+    google.protobuf.Duration schedule_to_start_timeout = 9;
+    /// Maximum time the local activity is allowed to execute after the task is dispatched. This
+    /// timeout is always retryable. Either or both of `schedule_to_close_timeout` and this must be
+    /// specified. If set, this must be <= `schedule_to_close_timeout`, otherwise, it will be
+    /// clamped down.
+    google.protobuf.Duration start_to_close_timeout = 10;
+    /// Specify a retry policy for the local activity. By default local activities will be retried
+    /// indefinitely.
+    common.RetryPolicy retry_policy = 11;
+    /// If the activity is retrying and backoff would exceed this value, lang will be told to
+    /// schedule a timer and retry the activity after. Otherwise, backoff will happen internally in
+    /// core. Defaults to 1 minute.
+    google.protobuf.Duration local_retry_threshold = 12;
+    /// Defines how the workflow will wait (or not) for cancellation of the activity to be
+    /// confirmed. Lang should default this to `WAIT_CANCELLATION_COMPLETED`, even though proto
+    /// will default to `TRY_CANCEL` automatically.
     ActivityCancellationType cancellation_type = 13;
 }
 
@@ -95,6 +141,11 @@ message RequestCancelActivity {
     uint32 seq = 1;
 }
 
+message RequestCancelLocalActivity {
+    /// Lang's incremental sequence number as passed to `ScheduleLocalActivity`
+    uint32 seq = 1;
+}
+
 message QueryResult {
     /// Corresponds to the id provided in the activation job
     string query_id = 1;

package/sdk-core/protos/local/{workflow_completion.proto → temporal/sdk/core/workflow_completion/workflow_completion.proto}

@@ -2,12 +2,12 @@ syntax = "proto3";
 
 package coresdk.workflow_completion;
 
-import "common.proto";
-import "workflow_commands.proto";
 import "temporal/api/failure/v1/message.proto";
+import "temporal/sdk/core/common/common.proto";
+import "temporal/sdk/core/workflow_commands/workflow_commands.proto";
 
 /// Result of a single workflow activation, reported from lang to core
-message WFActivationCompletion {
+message WorkflowActivationCompletion {
     // The task queue the workflow activation you are completing originated from
     string task_queue = 1;
     // The run id from the workflow activation you are completing

package/sdk-core/sdk/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "temporal-sdk"
+version = "0.1.0-alpha.1"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0"
+crossbeam = "0.8"
+derive_more = "0.99"
+futures = "0.3"
+parking_lot = { version = "0.11", features = ["send_guard"] }
+prost-types = "0.9"
+serde = "1.0"
+tokio = { version = "1.1", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs"] }
+tokio-util = { version = "0.6.9" }
+tokio-stream = "0.1"
+tonic = "0.6"
+tracing = { version = "0.1", features = ["log-always"] }
+
+[dependencies.temporal-sdk-core]
+path = "../core"
+version = "0.1"
+
+[dependencies.temporal-sdk-core-protos]
+path = "../sdk-core-protos"
+version = "0.1"
+
+[dependencies.temporal-sdk-core-api]
+path = "../core-api"
+version = "0.1"