temporalio 0.0.1

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

@@ -0,0 +1,297 @@
+syntax = "proto3";
+
+/**
+ * Definitions for commands from a workflow in lang SDK to core. While a workflow processes a batch
+ * of activation jobs, it accumulates these commands to be sent back to core to conclude that
+ * activation.
+ */
+package coresdk.workflow_commands;
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+import "temporal/api/common/v1/message.proto";
+import "temporal/api/enums/v1/workflow.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 {
+        StartTimer start_timer = 1;
+        ScheduleActivity schedule_activity = 2;
+        QueryResult respond_to_query = 3;
+        RequestCancelActivity request_cancel_activity = 4;
+        CancelTimer cancel_timer = 5;
+        CompleteWorkflowExecution complete_workflow_execution = 6;
+        FailWorkflowExecution fail_workflow_execution = 7;
+        ContinueAsNewWorkflowExecution continue_as_new_workflow_execution = 8;
+        CancelWorkflowExecution cancel_workflow_execution = 9;
+        SetPatchMarker set_patch_marker = 10;
+        StartChildWorkflowExecution start_child_workflow_execution = 11;
+        CancelChildWorkflowExecution cancel_child_workflow_execution = 12;
+        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;
+        UpsertWorkflowSearchAttributes upsert_workflow_search_attributes = 18;
+    }
+}
+
+message StartTimer {
+    /// Lang's incremental sequence number, used as the operation identifier
+    uint32 seq = 1;
+    google.protobuf.Duration start_to_fire_timeout = 2;
+}
+
+message CancelTimer {
+    /// Lang's incremental sequence number as passed to `StartTimer`
+    uint32 seq = 1;
+}
+
+message ScheduleActivity {
+    /// Lang's incremental sequence number, used as the operation identifier
+    uint32 seq = 1;
+    string activity_id = 2;
+    string activity_type = 3;
+    string namespace = 4;
+    // The name of the task queue to place this activity request in
+    string task_queue = 5;
+    map<string, temporal.api.common.v1.Payload> headers = 6;
+    /// Arguments/input to the activity. Called "input" upstream.
+    repeated temporal.api.common.v1.Payload arguments = 7;
+    /// Indicates how long the caller is willing to wait for an activity completion. Limits how long
+    /// retries will be attempted. Either this or start_to_close_timeout_seconds must be specified.
+    /// When not specified defaults to the workflow execution timeout.
+    google.protobuf.Duration schedule_to_close_timeout = 8;
+    /// Limits time an activity task can stay in a task queue before a worker picks it up. 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 or workflow execution timeout if not specified.
+    google.protobuf.Duration schedule_to_start_timeout = 9;
+    /// Maximum time an activity is allowed to execute after a pick up by a worker. This timeout is
+    /// always retryable. Either this or schedule_to_close_timeout must be specified.
+    google.protobuf.Duration start_to_close_timeout = 10;
+    /// Maximum time allowed between successful worker heartbeats.
+    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 1.
+    temporal.api.common.v1.RetryPolicy retry_policy = 12;
+    /// Defines how the workflow will wait (or not) for cancellation of the activity to be confirmed
+    ActivityCancellationType cancellation_type = 13;
+    /// If set, the worker will not tell the service that it can immediately start executing this
+    /// activity. When unset/default, workers will always attempt to do so if activity execution
+    /// slots are available.
+    bool do_not_eagerly_execute = 14;
+}
+
+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, temporal.api.common.v1.Payload> headers = 6;
+    /// Arguments/input to the activity.
+    repeated temporal.api.common.v1.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.
+    temporal.api.common.v1.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;
+}
+
+enum ActivityCancellationType {
+    /// Initiate a cancellation request and immediately report cancellation to the workflow.
+    TRY_CANCEL = 0;
+    /// Wait for activity cancellation completion. Note that activity must heartbeat to receive a
+    /// cancellation notification. This can block the cancellation for a long time if activity
+    /// doesn't heartbeat or chooses to ignore the cancellation request.
+    WAIT_CANCELLATION_COMPLETED = 1;
+    /// Do not request cancellation of the activity and immediately report cancellation to the
+    /// workflow
+    ABANDON = 2;
+}
+
+message RequestCancelActivity {
+    /// Lang's incremental sequence number as passed to `ScheduleActivity`
+    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;
+    oneof variant {
+        QuerySuccess succeeded = 2;
+        temporal.api.failure.v1.Failure failed = 3;
+    }
+}
+
+message QuerySuccess {
+    temporal.api.common.v1.Payload response = 1;
+}
+
+/// Issued when the workflow completes successfully
+message CompleteWorkflowExecution {
+    temporal.api.common.v1.Payload result = 1;
+}
+
+/// Issued when the workflow errors out
+message FailWorkflowExecution {
+    temporal.api.failure.v1.Failure failure = 1;
+}
+
+// Continue the workflow as a new execution
+message ContinueAsNewWorkflowExecution {
+    // The identifier the lang-specific sdk uses to execute workflow code
+    string workflow_type = 1;
+    // Task queue for the new workflow execution
+    string task_queue = 2;
+    // Inputs to the workflow code. Should be specified. Will not re-use old arguments, as that
+    // typically wouldn't make any sense.
+    repeated temporal.api.common.v1.Payload arguments = 3;
+    // Timeout for a single run of the new workflow. Will not re-use current workflow's value.
+    google.protobuf.Duration workflow_run_timeout = 4;
+    // Timeout of a single workflow task. Will not re-use current workflow's value.
+    google.protobuf.Duration workflow_task_timeout = 5;
+    // If set, the new workflow will have this memo. If unset, re-uses the current workflow's memo
+    map<string, temporal.api.common.v1.Payload> memo = 6;
+    // If set, the new workflow will have these headers. Will *not* re-use current workflow's
+    // headers otherwise.
+    map<string, temporal.api.common.v1.Payload> headers = 7;
+    // If set, the new workflow will have these search attributes. If unset, re-uses the current
+    // workflow's search attributes.
+    map<string, temporal.api.common.v1.Payload> search_attributes = 8;
+    // If set, the new workflow will have this retry policy. If unset, re-uses the current
+    // workflow's retry policy.
+    temporal.api.common.v1.RetryPolicy retry_policy = 9;
+}
+
+/// Indicate a workflow has completed as cancelled. Generally sent as a response to an activation
+/// containing a cancellation job.
+message CancelWorkflowExecution {}
+
+/// A request to set/check if a certain patch is present or not
+message SetPatchMarker {
+    // A user-chosen identifier for this patch. If the same identifier is used in multiple places in
+    // the code, those places are considered to be versioned as one unit. IE: The check call will
+    // return the same result for all of them
+    string patch_id = 1;
+    // Can be set to true to indicate that branches using this change are being removed, and all
+    // future worker deployments will only have the "with change" code in them.
+    bool deprecated = 2;
+}
+
+/// Start a child workflow execution
+message StartChildWorkflowExecution {
+    /// Lang's incremental sequence number, used as the operation identifier
+    uint32 seq = 1;
+    string namespace = 2;
+    string workflow_id = 3;
+    string workflow_type = 4;
+    string task_queue = 5;
+    repeated temporal.api.common.v1.Payload input = 6;
+    /// Total workflow execution timeout including retries and continue as new.
+    google.protobuf.Duration workflow_execution_timeout = 7;
+    /// Timeout of a single workflow run.
+    google.protobuf.Duration workflow_run_timeout = 8;
+    /// Timeout of a single workflow task.
+    google.protobuf.Duration workflow_task_timeout = 9;
+    /// Default: PARENT_CLOSE_POLICY_TERMINATE.
+    child_workflow.ParentClosePolicy parent_close_policy = 10;
+    // string control = 11; (unused from StartChildWorkflowExecutionCommandAttributes)
+    // Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE.
+    temporal.api.enums.v1.WorkflowIdReusePolicy workflow_id_reuse_policy = 12;
+    temporal.api.common.v1.RetryPolicy retry_policy = 13;
+    string cron_schedule = 14;
+    /// Header fields
+    map<string, temporal.api.common.v1.Payload> headers = 15;
+    /// Memo fields
+    map<string, temporal.api.common.v1.Payload> memo = 16;
+    /// Search attributes
+    map<string, temporal.api.common.v1.Payload> search_attributes = 17;
+    /// Defines behaviour of the underlying workflow when child workflow cancellation has been requested.
+    child_workflow.ChildWorkflowCancellationType cancellation_type = 18;
+}
+
+/// Cancel a child workflow
+message CancelChildWorkflowExecution {
+    // Sequence number as given to the `StartChildWorkflowExecution` command
+    uint32 child_workflow_seq = 1;
+}
+
+/// Request cancellation of an external workflow execution (which may be a started child)
+message RequestCancelExternalWorkflowExecution {
+    /// Lang's incremental sequence number, used as the operation identifier
+    uint32 seq = 1;
+    // What workflow is being targeted
+    oneof target {
+        // A specific workflow instance
+        common.NamespacedWorkflowExecution workflow_execution = 2;
+        // The desired target must be a child of the issuing workflow, and this is its workflow id
+        string child_workflow_id = 3;
+    }
+}
+
+/// Send a signal to an external or child workflow
+message SignalExternalWorkflowExecution {
+    /// Lang's incremental sequence number, used as the operation identifier
+    uint32 seq = 1;
+    // What workflow is being targeted
+    oneof target {
+        // A specific workflow instance
+        common.NamespacedWorkflowExecution workflow_execution = 2;
+        // The desired target must be a child of the issuing workflow, and this is its workflow id
+        string child_workflow_id = 3;
+    }
+    /// Name of the signal handler
+    string signal_name = 4;
+    /// Arguments for the handler
+    repeated temporal.api.common.v1.Payload args = 5;
+    /// Headers to attach to the signal
+    map<string, temporal.api.common.v1.Payload> headers = 6;
+}
+
+/// Can be used to cancel not-already-sent `SignalExternalWorkflowExecution` commands
+message CancelSignalWorkflow {
+    /// Lang's incremental sequence number as passed to `SignalExternalWorkflowExecution`
+    uint32 seq = 1;
+}
+
+message UpsertWorkflowSearchAttributes {
+    /// SearchAttributes fields - equivalent to indexed_fields on api. Key = search index, Value =
+    /// value?
+    map<string, temporal.api.common.v1.Payload> search_attributes = 1;
+}

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

@@ -0,0 +1,29 @@
+syntax = "proto3";
+
+package coresdk.workflow_completion;
+
+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 WorkflowActivationCompletion {
+    // The run id from the workflow activation you are completing
+    string run_id = 1;
+    oneof status {
+        Success successful = 2;
+        Failure failed = 3;
+    }
+}
+
+/// Successful workflow activation with a list of commands generated by the workflow execution
+message Success {
+    // A list of commands to send back to the temporal server
+    repeated workflow_commands.WorkflowCommand commands = 1;
+}
+
+/// Failure to activate or execute a workflow
+message Failure {
+    temporal.api.failure.v1.Failure failure = 1;
+}
+

data/bridge/sdk-core/protos/testsrv_upstream/api-linter.yaml

@@ -0,0 +1,38 @@
+- included_paths:
+    - '**/*.proto'
+  disabled_rules:
+    - 'core::0192::has-comments'
+
+- included_paths:
+    - '**/message.proto'
+  disabled_rules:
+    - 'core::0122::name-suffix'
+    - 'core::0123::resource-annotation'
+
+- included_paths:
+    - '**/testservice/v1/request_response.proto'
+  disabled_rules:
+    - 'core::0122::name-suffix'
+    - 'core::0131::request-name-required'
+    - 'core::0131::request-unknown-fields'
+    - 'core::0132::request-parent-required'
+    - 'core::0132::request-unknown-fields'
+    - 'core::0132::response-unknown-fields'
+    - 'core::0134::request-unknown-fields'
+    - 'core::0158::request-page-size-field'
+    - 'core::0158::request-page-token-field'
+    - 'core::0158::response-next-page-token-field'
+    - 'core::0158::response-plural-first-field'
+    - 'core::0158::response-repeated-first-field'
+
+- included_paths:
+    - '**/testservice/v1/service.proto'
+  disabled_rules:
+    - 'core::0127::http-annotation'
+    - 'core::0131::method-signature'
+    - 'core::0131::response-message-name'
+
+- included_paths:
+    - 'dependencies/gogoproto/gogo.proto'
+  disabled_rules:
+    - 'all'

data/bridge/sdk-core/protos/testsrv_upstream/buf.yaml

@@ -0,0 +1,13 @@
+version: v1beta1
+build:
+  roots:
+    - .
+lint:
+  ignore:
+    - dependencies
+  use:
+    - DEFAULT
+breaking:
+  ignore:
+  use:
+    - PACKAGE

data/bridge/sdk-core/protos/testsrv_upstream/dependencies/gogoproto/gogo.proto

@@ -0,0 +1,141 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/temporalio/gogo-protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto2";
+package gogoproto;
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "github.com/gogo/protobuf/gogoproto";
+
+extend google.protobuf.EnumOptions {
+    optional bool goproto_enum_prefix = 62001;
+    optional bool goproto_enum_stringer = 62021;
+    optional bool enum_stringer = 62022;
+    optional string enum_customname = 62023;
+    optional bool enumdecl = 62024;
+}
+
+extend google.protobuf.EnumValueOptions {
+    optional string enumvalue_customname = 66001;
+}
+
+extend google.protobuf.FileOptions {
+    optional bool goproto_getters_all = 63001;
+    optional bool goproto_enum_prefix_all = 63002;
+    optional bool goproto_stringer_all = 63003;
+    optional bool verbose_equal_all = 63004;
+    optional bool face_all = 63005;
+    optional bool gostring_all = 63006;
+    optional bool populate_all = 63007;
+    optional bool stringer_all = 63008;
+    optional bool onlyone_all = 63009;
+
+    optional bool equal_all = 63013;
+    optional bool description_all = 63014;
+    optional bool testgen_all = 63015;
+    optional bool benchgen_all = 63016;
+    optional bool marshaler_all = 63017;
+    optional bool unmarshaler_all = 63018;
+    optional bool stable_marshaler_all = 63019;
+
+    optional bool sizer_all = 63020;
+
+    optional bool goproto_enum_stringer_all = 63021;
+    optional bool enum_stringer_all = 63022;
+
+    optional bool unsafe_marshaler_all = 63023;
+    optional bool unsafe_unmarshaler_all = 63024;
+
+    optional bool goproto_extensions_map_all = 63025;
+    optional bool goproto_unrecognized_all = 63026;
+    optional bool gogoproto_import = 63027;
+    optional bool protosizer_all = 63028;
+    optional bool compare_all = 63029;
+    optional bool typedecl_all = 63030;
+    optional bool enumdecl_all = 63031;
+
+    optional bool goproto_registration = 63032;
+    optional bool messagename_all = 63033;
+
+    optional bool goproto_sizecache_all = 63034;
+    optional bool goproto_unkeyed_all = 63035;
+}
+
+extend google.protobuf.MessageOptions {
+    optional bool goproto_getters = 64001;
+    optional bool goproto_stringer = 64003;
+    optional bool verbose_equal = 64004;
+    optional bool face = 64005;
+    optional bool gostring = 64006;
+    optional bool populate = 64007;
+    optional bool stringer = 67008;
+    optional bool onlyone = 64009;
+
+    optional bool equal = 64013;
+    optional bool description = 64014;
+    optional bool testgen = 64015;
+    optional bool benchgen = 64016;
+    optional bool marshaler = 64017;
+    optional bool unmarshaler = 64018;
+    optional bool stable_marshaler = 64019;
+
+    optional bool sizer = 64020;
+
+    optional bool unsafe_marshaler = 64023;
+    optional bool unsafe_unmarshaler = 64024;
+
+    optional bool goproto_extensions_map = 64025;
+    optional bool goproto_unrecognized = 64026;
+
+    optional bool protosizer = 64028;
+    optional bool compare = 64029;
+
+    optional bool typedecl = 64030;
+
+    optional bool messagename = 64033;
+
+    optional bool goproto_sizecache = 64034;
+    optional bool goproto_unkeyed = 64035;
+}
+
+extend google.protobuf.FieldOptions {
+    optional bool nullable = 65001;
+    optional bool embed = 65002;
+    optional string customtype = 65003;
+    optional string customname = 65004;
+    optional string jsontag = 65005;
+    optional string moretags = 65006;
+    optional string casttype = 65007;
+    optional string castkey = 65008;
+    optional string castvalue = 65009;
+
+    optional bool stdtime = 65010;
+    optional bool stdduration = 65011;
+    optional bool wktpointer = 65012;
+}

data/bridge/sdk-core/protos/testsrv_upstream/temporal/api/testservice/v1/request_response.proto

@@ -0,0 +1,63 @@
+// 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.testservice.v1;
+
+option go_package = "go.temporal.io/api/testservice/v1;testservice";
+option java_package = "io.temporal.api.testservice.v1";
+option java_multiple_files = true;
+option java_outer_classname = "RequestResponseProto";
+option ruby_package = "Temporal::Api::TestService::V1";
+option csharp_namespace = "Temporal.Api.TestService.V1";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+import "dependencies/gogoproto/gogo.proto";
+
+message LockTimeSkippingRequest {
+}
+
+message LockTimeSkippingResponse {
+}
+
+message UnlockTimeSkippingRequest {
+}
+
+message UnlockTimeSkippingResponse {
+}
+
+message SleepUntilRequest {
+    google.protobuf.Timestamp timestamp = 1 [(gogoproto.stdtime) = true];
+}
+
+message SleepRequest {
+    google.protobuf.Duration duration = 1 [(gogoproto.stdduration) = true];
+}
+
+message SleepResponse {
+}
+
+message GetCurrentTimeResponse {
+    google.protobuf.Timestamp time = 1 [(gogoproto.stdtime) = true];
+}

data/bridge/sdk-core/protos/testsrv_upstream/temporal/api/testservice/v1/service.proto

@@ -0,0 +1,90 @@
+// 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.testservice.v1;
+
+option go_package = "go.temporal.io/api/testservice/v1;testservice";
+option java_package = "io.temporal.api.testservice.v1";
+option java_multiple_files = true;
+option java_outer_classname = "ServiceProto";
+option ruby_package = "Temporal::Api::TestService::V1";
+option csharp_namespace = "Temporal.Api.TestService.V1";
+
+import "temporal/api/testservice/v1/request_response.proto";
+import "google/protobuf/empty.proto";
+
+// TestService API defines an interface supported only by the Temporal Test Server.
+// It provides functionality needed or supported for testing purposes only.
+//
+// This is an EXPERIMENTAL API.
+service TestService {
+    // LockTimeSkipping increments Time Locking Counter by one.
+    //
+    // If Time Locking Counter is positive, time skipping is locked (disabled).
+    // When time skipping is disabled, the time in test server is moving normally, with a real time pace.
+    // Test Server is typically started with locked time skipping and Time Locking Counter = 1.
+    //
+    // LockTimeSkipping and UnlockTimeSkipping calls are counted.
+    rpc LockTimeSkipping (LockTimeSkippingRequest) returns (LockTimeSkippingResponse) {
+    }
+
+    // UnlockTimeSkipping decrements Time Locking Counter by one.
+    //
+    // If the counter reaches 0, it unlocks time skipping and fast forwards time.
+    // LockTimeSkipping and UnlockTimeSkipping calls are counted. Calling UnlockTimeSkipping does not
+    // guarantee that time is going to be fast forwarded as another lock can be holding it.
+    //
+    // Time Locking Counter can't be negative, unbalanced calls to UnlockTimeSkipping will lead to rpc call failure
+    rpc UnlockTimeSkipping (UnlockTimeSkippingRequest) returns (UnlockTimeSkippingResponse) {
+    }
+
+    // This call returns only when the Test Server Time advances by the specified duration.
+    // This is an EXPERIMENTAL API.
+    rpc Sleep (SleepRequest) returns (SleepResponse) {
+    }
+
+    // This call returns only when the Test Server Time advances to the specified timestamp.
+    // If the current Test Server Time is beyond the specified timestamp, returns immediately.
+    // This is an EXPERIMENTAL API.
+    rpc SleepUntil (SleepUntilRequest) returns (SleepResponse) {
+    }
+
+    // UnlockTimeSkippingWhileSleep decreases time locking counter by one and increases it back
+    // once the Test Server Time advances by the duration specified in the request.
+    //
+    // This call returns only when the Test Server Time advances by the specified duration.
+    //
+    // If it is called when Time Locking Counter is
+    //   - more than 1 and no other unlocks are coming in, rpc call will block for the specified duration, time will not be fast forwarded.
+    //   - 1, it will lead to fast forwarding of the time by the duration specified in the request and quick return of this rpc call.
+    //   - 0 will lead to rpc call failure same way as an unbalanced UnlockTimeSkipping.
+    rpc UnlockTimeSkippingWithSleep (SleepRequest) returns (SleepResponse) {
+    }
+
+    // GetCurrentTime returns the current Temporal Test Server time
+    //
+    // This time might not be equal to {@link System#currentTimeMillis()} due to time skipping.
+    rpc GetCurrentTime (google.protobuf.Empty) returns (GetCurrentTimeResponse) {
+    }
+}

data/bridge/sdk-core/rustfmt.toml

@@ -0,0 +1 @@
+imports_granularity="Crate"