Eliminate upstream protos

.buildkite/pipeline.yml

@@ -13,7 +13,7 @@ steps:
     agents:
       queue: "default"
       docker: "*"
-    command: "cargo clippy --all -- -D warnings"
+    command: "cargo clippy --workspace --all-features --all-targets -- -D warnings && cargo clippy --test integ_tests --all-features -- --D warnings"
     timeout_in_minutes: 15
     plugins:
       - docker-compose#v3.0.0:

build.rs

@@ -14,10 +14,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             "temporal.api.command.v1.Command.attributes",
             "#[derive(::derive_more::From)]",
         )
-        .type_attribute("coresdk.Command.variant", "#[derive(::derive_more::From)]")
-        .type_attribute("coresdk.WFActivationJob", "#[derive(::derive_more::From)]")
         .type_attribute(
-            "coresdk.WFActivationJob.variant",
+            "coresdk.workflow_commands.WorkflowCommand.variant",
+            "#[derive(::derive_more::From)]",
+        )
+        .type_attribute(
+            "coresdk.workflow_activation.wf_activation_job",
+            "#[derive(::derive_more::From)]",
+        )
+        .type_attribute(
+            "coresdk.workflow_activation.WFActivationJob.variant",
             "#[derive(::derive_more::From)]",
         )
         .type_attribute("coresdk.Task.variant", "#[derive(::derive_more::From)]")

protos/local/activity_result.proto

@@ -0,0 +1,30 @@
+syntax = "proto3";
+
+package coresdk.activity_result;
+
+import "common.proto";
+
+/// Used to report activity completion to core and to resolve the activity in a workflow activation
+message ActivityResult {
+    oneof status {
+        Success completed = 1;
+        Failure failed = 2;
+        Cancelation canceled = 3;
+    }
+}
+
+/// Used in ActivityResult to report cancellation
+message Cancelation {
+    repeated common.Payload details = 1;
+}
+
+/// Used in ActivityResult to report successful completion
+message Success {
+    repeated common.Payload result = 1;
+}
+
+/// Used in ActivityResult to report failure
+message Failure {
+    common.UserCodeFailure failure = 1;
+}
+

protos/local/activity_task.proto

@@ -0,0 +1,55 @@
+syntax = "proto3";
+
+/**
+ * Definitions of the different activity tasks returned from [crate::Core::poll_task].
+ */
+package coresdk.activity_task;
+
+import "common.proto";
+
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/duration.proto";
+
+message ActivityTask {
+    string activity_id = 1;
+    oneof variant {
+        // Start activity execution.
+        Start start = 2;
+        // Attempt to cancel activity execution.
+        Cancel cancel = 3;
+    }
+}
+
+/// Begin executing an activity
+message Start {
+    string workflow_namespace = 1;
+    /// The workflow's type name or function identifier
+    string workflow_type = 2;
+    common.WorkflowExecution workflow_execution = 3;
+    /// The activity's type name or function identifier
+    string activity_type = 4;
+    map<string, common.Payload> header_fields = 5;
+    /// Arguments to the activity
+    repeated common.Payload input = 6;
+    repeated common.Payload heartbeat_details = 7;
+
+    google.protobuf.Timestamp scheduled_time = 8;
+    google.protobuf.Timestamp current_attempt_scheduled_time = 9;
+    google.protobuf.Timestamp started_time = 10;
+    int32 attempt = 11;
+
+    google.protobuf.Duration schedule_to_close_timeout = 12;
+    google.protobuf.Duration start_to_close_timeout = 13;
+    google.protobuf.Duration heartbeat_timeout = 14;
+    /// This is an actual retry policy the service uses. It can be different from the one provided
+    /// (or not) during activity scheduling as the service can override the provided one in case its
+    /// values are not specified or exceed configured system limits.
+    common.RetryPolicy retry_policy = 15;
+}
+
+/// Attempt to cancel a running activity
+message Cancel {
+    // TODO: add attributes
+}
+
+

protos/local/common.proto

@@ -0,0 +1,61 @@
+syntax = "proto3";
+
+package coresdk.common;
+
+import "google/protobuf/duration.proto";
+
+// Many of the messages in here are exact or near duplicates of the protobufs defined by the
+// Temporal API. We dupe them here to introduce better ergonomics wherever possible, and to
+// decouple ourselves from upstream changes. Additionally, we have no need for wire compatibility
+// between core and lang sdks, since the lang SDK chooses which version of core it wants to use.
+
+// Used as arguments to activities, signals, queries, etc.
+message Payload {
+    map<string,bytes> metadata = 1;
+    bytes data = 2;
+}
+
+// Identifying information about a particular workflow execution
+message WorkflowExecution {
+    string workflow_id = 1;
+    string run_id = 2;
+}
+
+// Defines how an activity or workflow should be retried in the event of failure, timeout, etc.
+message RetryPolicy {
+    // Interval of the first retry. If backoff_coefficient is 1.0 then it is used for all
+    // retries.
+    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.
+    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.
+    repeated string non_retryable_error_types = 5;
+}
+
+// Represents a failure in user code, workflow or activity, which could've been triggered by
+// an exception or similar error mechanism like the error half of a Result type.
+//
+// This eventually needs to be converted into an upstream `Failure` which needs to handle a lot
+// more cases that the lang sdk does not care about. By default any lang sdk failure is an upstream
+// `ApplicationFailureInfo`.
+message UserCodeFailure {
+    // Human-specified or otherwise most-human-readable representation of the error.
+    string message = 1;
+    // A type identifier for the error, if the error is well-typed.
+    string type = 2;
+    // If known, the location the error was issued at.
+    string source = 3;
+    // If collected, a stack trace for the error.
+    string stack_trace = 4;
+    // Explicitly thrown user errors are able to indicate that retries should be prevented
+    bool non_retryable = 5;
+
+    UserCodeFailure cause = 6;
+}