temporalio 0.0.1

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

@@ -0,0 +1,210 @@
+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 InitTelemetryRequest {
+  string tracing_filter = 1;
+  oneof logging {
+    ConsoleLoggerOptions console = 2;
+    ForwardLoggerOptions forward = 3;
+  };
+
+  oneof tracing {
+    OtelCollectorOptions otel_tracing = 4;
+  }
+
+  oneof metrics {
+    OtelCollectorOptions otel_metrics = 5;
+    PrometheusOptions prometheus = 6;
+  }
+
+  message ConsoleLoggerOptions {}
+  message ForwardLoggerOptions {
+    LogLevel level = 1;
+  }
+
+  message OtelCollectorOptions {
+    string url = 1;
+    map<string, string> headers = 2;
+  }
+  message PrometheusOptions {
+    string export_bind_address = 1;
+  }
+}
+
+message CreateClientRequest {
+  string target_url = 1;
+  string namespace = 2;
+  string client_name = 3;
+  string client_version = 4;
+  string identity = 6;
+  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 InitResponse {
+  Error error = 1;
+
+  message Error {
+    string message = 1;
+  }
+}
+
+message CreateWorkerRequest {
+  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;
+  }
+}
+
+message PollWorkflowActivationRequest {
+}
+
+message PollWorkflowActivationResponse {
+  oneof response {
+    coresdk.workflow_activation.WorkflowActivation activation = 1;
+    Error error = 2;
+  }
+
+  message Error {
+    string message = 1;
+    bool shutdown = 2;
+  }
+}
+
+message PollActivityTaskRequest {
+}
+
+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 run_id = 1;
+}
+
+message RequestWorkflowEvictionResponse {
+  Error error = 1;
+
+  message Error {
+    string message = 1;
+  }
+}
+
+message ShutdownWorkerRequest {
+}
+
+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;
+  }
+}

data/bridge/sdk-core/protos/local/temporal/sdk/core/child_workflow/child_workflow.proto

@@ -0,0 +1,77 @@
+syntax = "proto3";
+
+package coresdk.child_workflow;
+
+import "temporal/api/common/v1/message.proto";
+import "temporal/api/failure/v1/message.proto";
+import "temporal/sdk/core/common/common.proto";
+
+/**
+ * Used by core to resolve child workflow executions.
+ */
+message ChildWorkflowResult {
+    oneof status {
+        Success completed = 1;
+        Failure failed = 2;
+        Cancellation cancelled = 3;
+    }
+}
+
+/**
+ * Used in ChildWorkflowResult to report successful completion.
+ */
+message Success {
+    temporal.api.common.v1.Payload result = 1;
+}
+
+/**
+ * Used in ChildWorkflowResult to report non successful outcomes such as
+ * application failures, timeouts, terminations, and cancellations.
+ */
+message Failure {
+    temporal.api.failure.v1.Failure failure = 1;
+}
+
+/**
+ * Used in ChildWorkflowResult to report cancellation.
+ * Failure should be ChildWorkflowFailure with a CanceledFailure cause.
+ */
+message Cancellation {
+    temporal.api.failure.v1.Failure failure = 1;
+}
+
+/**
+ * Used by the service to determine the fate of a child workflow
+ * in case its parent is closed.
+ */
+enum ParentClosePolicy {
+    /** Let's the server set the default. */
+    PARENT_CLOSE_POLICY_UNSPECIFIED = 0;
+    /** Terminate means terminating the child workflow. */
+    PARENT_CLOSE_POLICY_TERMINATE = 1;
+    /** Abandon means not doing anything on the child workflow. */
+    PARENT_CLOSE_POLICY_ABANDON = 2;
+    /** Cancel means requesting cancellation on the child workflow. */
+    PARENT_CLOSE_POLICY_REQUEST_CANCEL = 3;
+}
+
+/** Possible causes of failure to start a child workflow */
+enum StartChildWorkflowExecutionFailedCause {
+    START_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_UNSPECIFIED = 0;
+    START_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_EXISTS = 1;
+}
+
+/**
+ * Controls at which point to report back to lang when a child workflow is cancelled
+ */
+enum ChildWorkflowCancellationType {
+    /** Do not request cancellation of the child workflow if already scheduled */
+    ABANDON = 0;
+    /** Initiate a cancellation request and immediately report cancellation to the parent. */
+    TRY_CANCEL = 1;
+    /** Wait for child cancellation completion. */
+    WAIT_CANCELLATION_COMPLETED = 2;
+    /** Request cancellation of the child and wait for confirmation that the request was received. */
+    WAIT_CANCELLATION_REQUESTED = 3;
+}
+

data/bridge/sdk-core/protos/local/temporal/sdk/core/common/common.proto

@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+package coresdk.common;
+
+import "google/protobuf/duration.proto";
+
+// Identifying information about a particular workflow execution, including namespace
+message NamespacedWorkflowExecution {
+    // Namespace the workflow run is located in
+    string namespace = 1;
+    // Can never be empty
+    string workflow_id = 2;
+    // May be empty if the most recent run of the workflow with the given ID is being targeted
+    string run_id = 3;
+}

data/bridge/sdk-core/protos/local/temporal/sdk/core/core_interface.proto

@@ -0,0 +1,30 @@
+syntax = "proto3";
+
+package coresdk;
+
+// 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/duration.proto";
+import "google/protobuf/empty.proto";
+import "google/protobuf/timestamp.proto";
+import "temporal/api/common/v1/message.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 {
+    bytes task_token = 1;
+    repeated temporal.api.common.v1.Payload details = 2;
+}
+
+// A request as given to `complete_activity_task`
+message ActivityTaskCompletion {
+    bytes task_token = 1;
+    activity_result.ActivityExecutionResult result = 2;
+}

data/bridge/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;
+}

data/bridge/sdk-core/protos/local/temporal/sdk/core/workflow_activation/workflow_activation.proto

@@ -0,0 +1,261 @@
+syntax = "proto3";
+
+/**
+ * Definitions of the different workflow activation jobs returned from [crate::Core::poll_task]. The
+ * lang SDK applies these activation jobs to drive workflows.
+ */
+package coresdk.workflow_activation;
+
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/duration.proto";
+import "temporal/api/failure/v1/message.proto";
+import "temporal/api/common/v1/message.proto";
+import "temporal/api/enums/v1/workflow.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 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;
+    /// The current time as understood by the workflow, which is set by workflow task started events
+    google.protobuf.Timestamp timestamp = 2;
+    /// Whether or not the activation is replaying past events
+    bool is_replaying = 3;
+    /// Current history length as determined by the event id of the most recently processed event.
+    /// This ensures that the number is always deterministic
+    uint32 history_length = 4;
+    /// The things to do upon activating the workflow
+    repeated WorkflowActivationJob jobs = 5;
+}
+
+message WorkflowActivationJob {
+    oneof variant {
+        /// Begin a workflow for the first time
+        StartWorkflow start_workflow = 1;
+        /// A timer has fired, allowing whatever was waiting on it (if anything) to proceed
+        FireTimer fire_timer = 2;
+        /// Workflow was reset. The randomness seed must be updated.
+        UpdateRandomSeed update_random_seed = 4;
+        /// A request to query the workflow was received.
+        QueryWorkflow query_workflow = 5;
+        /// A request to cancel the workflow was received.
+        CancelWorkflow cancel_workflow = 6;
+        /// A request to signal the workflow was received.
+        SignalWorkflow signal_workflow = 7;
+        /// An activity was resolved, result could be completed, failed or cancelled
+        ResolveActivity resolve_activity = 8;
+        /// A patch marker has been detected and lang is being told that change exists. This
+        /// job is strange in that it is sent pre-emptively to lang without any corresponding
+        /// command being sent first.
+        NotifyHasPatch notify_has_patch = 9;
+        /// A child workflow execution has started or failed to start
+        ResolveChildWorkflowExecutionStart resolve_child_workflow_execution_start = 10;
+        /// A child workflow was resolved, result could be completed or failed
+        ResolveChildWorkflowExecution resolve_child_workflow_execution = 11;
+        /// An attempt to signal an external workflow resolved
+        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 [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
+        /// job list. The string value is a reason for eviction.
+        RemoveFromCache remove_from_cache = 50;
+    }
+}
+
+// Start a new workflow
+message StartWorkflow {
+    // The identifier the lang-specific sdk uses to execute workflow code
+    string workflow_type = 1;
+    // The workflow id used on the temporal server
+    string workflow_id = 2;
+    // Inputs to the workflow code
+    repeated temporal.api.common.v1.Payload arguments = 3;
+    // The seed must be used to initialize the random generator used by SDK.
+    // RandomSeedUpdatedAttributes are used to deliver seed updates.
+    uint64 randomness_seed = 4;
+    // Used to add metadata e.g. for tracing and auth, meant to be read and written to by interceptors.
+    map<string, temporal.api.common.v1.Payload> headers = 5;
+    // Identity of the client who requested this execution
+    string identity = 6;
+    // If this workflow is a child, information about the parent
+    common.NamespacedWorkflowExecution parent_workflow_info = 7;
+    // Total workflow execution timeout including retries and continue as new.
+    google.protobuf.Duration workflow_execution_timeout = 8;
+    // Timeout of a single workflow run.
+    google.protobuf.Duration workflow_run_timeout = 9;
+    // Timeout of a single workflow task.
+    google.protobuf.Duration workflow_task_timeout = 10;
+    // Run id of the previous workflow which continued-as-new or retired or cron executed into this
+    // workflow, if any.
+    string continued_from_execution_run_id = 11;
+    // If this workflow was a continuation, indicates the type of continuation.
+    temporal.api.enums.v1.ContinueAsNewInitiator continued_initiator = 12;
+    // If this workflow was a continuation and that continuation failed, the details of that.
+    temporal.api.failure.v1.Failure continued_failure = 13;
+    // If this workflow was a continuation and that continuation completed, the details of that.
+    temporal.api.common.v1.Payloads last_completion_result = 14;
+    // This is the very first run id the workflow ever had, following continuation chains.
+    string first_execution_run_id = 15;
+    // This workflow's retry policy
+    temporal.api.common.v1.RetryPolicy retry_policy = 16;
+    // Starting at 1, the number of times we have tried to execute this workflow
+    int32 attempt = 17;
+    // If this workflow runs on a cron schedule, it will appear here
+    string cron_schedule = 18;
+    // The absolute time at which the workflow will be timed out.
+    // This is passed without change to the next run/retry of a workflow.
+    google.protobuf.Timestamp workflow_execution_expiration_time = 19;
+    // For a cron workflow, this contains the amount of time between when this iteration of
+    // the cron workflow was scheduled and when it should run next per its cron_schedule.
+    google.protobuf.Duration cron_schedule_to_schedule_interval = 20;
+    // User-defined memo
+    temporal.api.common.v1.Memo memo = 21;
+    // Search attributes created/updated when this workflow was started
+    temporal.api.common.v1.SearchAttributes search_attributes = 22;
+}
+
+/// Notify a workflow that a timer has fired
+message FireTimer {
+    /// Sequence number as provided by lang in the corresponding StartTimer command
+    uint32 seq = 1;
+}
+
+/// Notify a workflow that an activity has been resolved
+message ResolveActivity {
+    /// Sequence number as provided by lang in the corresponding ScheduleActivity command
+    uint32 seq = 1;
+    activity_result.ActivityResolution result = 2;
+}
+
+/// Notify a workflow that a start child workflow execution request has succeeded, failed or was
+/// cancelled.
+message ResolveChildWorkflowExecutionStart {
+    /// Sequence number as provided by lang in the corresponding StartChildWorkflowExecution command
+    uint32 seq = 1;
+    oneof status {
+        ResolveChildWorkflowExecutionStartSuccess succeeded = 2;
+        ResolveChildWorkflowExecutionStartFailure failed = 3;
+        ResolveChildWorkflowExecutionStartCancelled cancelled = 4;
+    }
+}
+
+/// Simply pass the run_id to lang
+message ResolveChildWorkflowExecutionStartSuccess {
+    string run_id = 1;
+}
+
+/// Provide lang the cause of failure
+message ResolveChildWorkflowExecutionStartFailure {
+    /// Lang should have this information but it's more convenient to pass it back
+    /// for error construction on the lang side.
+    string workflow_id = 1;
+    string workflow_type = 2;
+    child_workflow.StartChildWorkflowExecutionFailedCause cause = 3;
+}
+
+/// `failure` should be ChildWorkflowFailure with cause set to CancelledFailure.
+/// The failure is constructed in core for lang's convenience.
+message ResolveChildWorkflowExecutionStartCancelled {
+  temporal.api.failure.v1.Failure failure = 1;
+}
+
+/// Notify a workflow that a child workflow execution has been resolved
+message ResolveChildWorkflowExecution {
+    /// Sequence number as provided by lang in the corresponding StartChildWorkflowExecution command
+    uint32 seq = 1;
+    child_workflow.ChildWorkflowResult result = 2;
+}
+
+/// Update the workflow's random seed
+message UpdateRandomSeed {
+    uint64 randomness_seed = 1;
+}
+
+/// Query a workflow
+message QueryWorkflow {
+    /// For PollWFTResp `query` field, this will be set to the special value `legacy`. For the
+    /// `queries` field, the server provides a unique identifier. If it is a `legacy` query,
+    /// lang cannot issue any commands in response other than to answer the query.
+    string query_id = 1;
+    /// The query's function/method/etc name
+    string query_type = 2;
+    repeated temporal.api.common.v1.Payload arguments = 3;
+    /// Headers attached to the query
+    map<string, temporal.api.common.v1.Payload> headers = 5;
+}
+
+/// Cancel a running workflow
+message CancelWorkflow {
+    /// Information from the cancellation request
+    repeated temporal.api.common.v1.Payload details = 1;
+}
+
+// Send a signal to a workflow
+message SignalWorkflow {
+    string signal_name = 1;
+    repeated temporal.api.common.v1.Payload input = 2;
+    // Identity of the sender of the signal
+    string identity = 3;
+    // Headers attached to the signal
+    map<string, temporal.api.common.v1.Payload> headers = 5;
+}
+
+// Inform lang what the result of a call to `patched` or similar API should be -- this is always
+// sent pre-emptively, so any time it is sent the change is present
+message NotifyHasPatch {
+    string patch_id = 1;
+}
+
+message ResolveSignalExternalWorkflow {
+    /// Sequence number as provided by lang in the corresponding SignalExternalWorkflowExecution
+    /// command
+    uint32 seq = 1;
+    /// If populated, this signal either failed to be sent or was cancelled depending on failure
+    /// type / info.
+    temporal.api.failure.v1.Failure failure = 2;
+}
+
+message ResolveRequestCancelExternalWorkflow {
+    /// Sequence number as provided by lang in the corresponding
+    /// RequestCancelExternalWorkflowExecution command
+    uint32 seq = 1;
+    /// If populated, this signal either failed to be sent or was cancelled depending on failure
+    /// type / info.
+    temporal.api.failure.v1.Failure failure = 2;
+}
+
+message RemoveFromCache {
+    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;
+}