@temporalio/core-bridge 1.7.0 → 1.7.2

package/sdk-core/protos/api_upstream/temporal/api/workflowservice/v1/request_response.proto

@@ -180,6 +180,10 @@ message StartWorkflowExecutionRequest {
     // StartWorkflowExecution.
     temporal.api.failure.v1.Failure continued_failure = 18;
     temporal.api.common.v1.Payloads last_completion_result = 19;
+    // Time to wait before dispatching the first workflow task. Cannot be used with `cron_schedule`.
+    // If the workflow gets a signal before the delay, a workflow task will be dispatched and the rest
+    // of the delay will be ignored.
+    google.protobuf.Duration workflow_start_delay = 20 [(gogoproto.stdduration) = true];
 }
 
 message StartWorkflowExecutionResponse {
@@ -237,12 +241,12 @@ message PollWorkflowTaskQueueRequest {
     // Each worker process should provide an ID unique to the specific set of code it is running
     // "checksum" in this field name isn't very accurate, it should be though of as an id.
     string binary_checksum = 4;
-    // If set, the worker is opting in to build-id based versioning and wishes to only
-    // receive tasks that are considered compatible with the version provided.
-    // Doing so only makes sense in conjunction with the `UpdateWorkerBuildIdOrdering` API.
-    // When `worker_versioning_id` has a `worker_build_id`, and `binary_checksum` is not
+    // If set, the worker is opting in to versioning and wishes to only
+    // receive tasks that are considered compatible with the version capabilities provided.
+    // Doing so only makes sense in conjunction with the `UpdateWorkerBuildIdCompatibility` API.
+    // When this field has a `worker_build_id`, and `binary_checksum` is not
     // set, that value should also be considered as the `binary_checksum`.
-    temporal.api.taskqueue.v1.VersionId worker_versioning_id = 5;
+    temporal.api.common.v1.WorkerVersionCapabilities worker_version_capabilities = 5;
 }
 
 message PollWorkflowTaskQueueResponse {
@@ -310,11 +314,12 @@ message RespondWorkflowTaskCompletedRequest {
     // Responses to the `queries` field in the task being responded to
     map<string, temporal.api.query.v1.WorkflowQueryResult> query_results = 8;
     string namespace = 9;
-    // If using versioning, worker should send the same id here that it used to
-    // poll for the workflow task.
-    // When `worker_versioning_id` has a `worker_build_id`, and `binary_checksum` is not
-    // set, that value should also be considered as the `binary_checksum`.
-    temporal.api.taskqueue.v1.VersionId worker_versioning_id = 10;
+    // If using versioning, the worker uses this field to indicate what version(s) it used to
+    // process the task. When this field has a `worker_build_id`, and `binary_checksum` is not set,
+    // that value should also be considered as the `binary_checksum`. Leaving this field empty when
+    // replying to a task has had this field previously populated in history in an error, and such
+    // a completion will be rejected.
+    temporal.api.common.v1.WorkerVersionStamp worker_version_stamp = 10;
     // Protocol messages piggybacking on a WFT as a transport
     repeated temporal.api.protocol.v1.Message messages = 11;
     // Data the SDK wishes to record for itself, but server need not interpret, and does not
@@ -359,10 +364,10 @@ message PollActivityTaskQueueRequest {
     // The identity of the worker/client
     string identity = 3;
     temporal.api.taskqueue.v1.TaskQueueMetadata task_queue_metadata = 4;
-    // If set, the worker is opting in to build-id based versioning and wishes to only
-    // receive tasks that are considered compatible with the version provided.
-    // Doing so only makes sense in conjunction with the `UpdateWorkerBuildIdOrdering` API.
-    temporal.api.taskqueue.v1.VersionId worker_versioning_id = 5;
+    // If set, the worker is opting in to versioning and wishes to only
+    // receive tasks that are considered compatible with the capabilities provided.
+    // Doing so only makes sense in conjunction with the `UpdateWorkerBuildIdCompatibility` API.
+    temporal.api.common.v1.WorkerVersionCapabilities worker_version_capabilities = 5;
 }
 
 message PollActivityTaskQueueResponse {
@@ -587,6 +592,8 @@ message SignalWorkflowExecutionRequest {
     // 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 = 8;
+    // Indicates that a new workflow task should not be generated when this signal is received.
+    bool skip_generate_workflow_task = 9;
 }
 
 message SignalWorkflowExecutionResponse {
@@ -624,6 +631,15 @@ message SignalWithStartWorkflowExecutionRequest {
     temporal.api.common.v1.Memo memo = 17;
     temporal.api.common.v1.SearchAttributes search_attributes = 18;
     temporal.api.common.v1.Header header = 19;
+    // Time to wait before dispatching the first workflow task. Cannot be used with `cron_schedule`.
+    // Note that the signal will be delivered with the first workflow task. If the workflow gets
+    // another SignalWithStartWorkflow before the delay and `skip_generate_workflow_task` is false
+    // or not set, a workflow task will be dispatched immediately and the rest of the delay period
+    // will be ignored, even if that request also had a delay. Signal via SignalWorkflowExecution
+    // will not unblock the workflow.
+    google.protobuf.Duration workflow_start_delay = 20 [(gogoproto.stdduration) = true];
+    // Indicates that a new workflow task should not be generated when this signal is received.
+    bool skip_generate_workflow_task = 21;
 }
 
 message SignalWithStartWorkflowExecutionResponse {
@@ -1038,47 +1054,106 @@ message ListSchedulesResponse {
 }
 
 // (-- api-linter: core::0134::request-mask-required=disabled
-//     aip.dev/not-precedent: UpdateWorkerBuildIdOrderingRequest doesn't follow Google API format --)
+//     aip.dev/not-precedent: UpdateWorkerBuildIdCompatibilityRequest doesn't follow Google API format --)
 // (-- api-linter: core::0134::request-resource-required=disabled
-//     aip.dev/not-precedent: UpdateWorkerBuildIdOrderingRequest RPC doesn't follow Google API format. --)
-message UpdateWorkerBuildIdOrderingRequest {
+//     aip.dev/not-precedent: UpdateWorkerBuildIdCompatibilityRequest RPC doesn't follow Google API format. --)
+message UpdateWorkerBuildIdCompatibilityRequest {
+    message AddNewCompatibleVersion {
+        // A new id to be added to an existing compatible set.
+        string new_build_id = 1;
+        // A build id which must already exist in the version sets known by the task queue. The new
+        // id will be stored in the set containing this id, marking it as compatible with
+        // the versions within.
+        string existing_compatible_build_id = 2;
+        // When set, establishes the compatible set being targeted as the overall default for the
+        // queue. If a different set was the current default, the targeted set will replace it as
+        // the new default.
+        bool make_set_default = 3;
+    }
+
     string namespace = 1;
-    // Must be set, the task queue to apply changes to. Because all workers on
-    // a given task queue must have the same set of workflow & activity
-    // implementations, there is no reason to specify a task queue type here.
+    // Must be set, the task queue to apply changes to. Because all workers on a given task queue
+    // must have the same set of workflow & activity implementations, there is no reason to specify
+    // a task queue type here.
     string task_queue = 2;
-    // The version id we are targeting.
-    temporal.api.taskqueue.v1.VersionId version_id = 3;
-    // When set, indicates that the `version_id` in this message is compatible
-    // with the one specified in this field. Because compatability should form
-    // a DAG, any build id can only be the "next compatible" version for one
-    // other ID of a certain type at a time, and any setting which would create a cycle is invalid.
-    temporal.api.taskqueue.v1.VersionId previous_compatible = 4;
-    // When set, establishes the specified `version_id` as the default of it's type
-    // for the queue. Workers matching it will begin processing new workflow executions.
-    // The existing default will be marked as a previous incompatible version
-    // to this one, assuming it is not also in `is_compatible_with`.
-    bool become_default = 5;
-}
-message UpdateWorkerBuildIdOrderingResponse {}
+    oneof operation {
+        // A new build id. This operation will create a new set which will be the new overall
+        // default version for the queue, with this id as its only member. This new set is
+        // incompatible with all previous sets/versions.
+        //
+        // (-- api-linter: core::0140::prepositions=disabled
+        //     aip.dev/not-precedent: In makes perfect sense here. --)
+        string add_new_build_id_in_new_default_set = 3;
+        // Adds a new id to an existing compatible set, see sub-message definition for more.
+        AddNewCompatibleVersion add_new_compatible_build_id = 4;
+        // Promote an existing set to be the current default (if it isn't already) by targeting
+        // an existing build id within it. This field's value is the extant build id.
+        //
+        // (-- api-linter: core::0140::prepositions=disabled
+        //     aip.dev/not-precedent: Names are hard. --)
+        string promote_set_by_build_id = 5;
+        // Promote an existing build id within some set to be the current default for that set.
+        //
+        // (-- api-linter: core::0140::prepositions=disabled
+        //     aip.dev/not-precedent: Within makes perfect sense here. --)
+        string promote_build_id_within_set = 6;
+    }
+}
+message UpdateWorkerBuildIdCompatibilityResponse {
+    // The id of the compatible set that the updated version was added to, or exists in. Users don't
+    // need to understand or care about this value, but it has value for debugging purposes.
+    string version_set_id = 1;
+}
 
 // (-- api-linter: core::0134::request-resource-required=disabled
-//     aip.dev/not-precedent: GetWorkerBuildIdOrderingRequest RPC doesn't follow Google API format. --)
-message GetWorkerBuildIdOrderingRequest {
+//     aip.dev/not-precedent: GetWorkerBuildIdCompatibilityRequest RPC doesn't follow Google API format. --)
+message GetWorkerBuildIdCompatibilityRequest {
     string namespace = 1;
-    // Must be set, the task queue to interrogate about worker id ordering
+    // Must be set, the task queue to interrogate about worker id compatibility.
     string task_queue = 2;
-    // Limits how deep the returned DAG will go. 1 will return only the
-    // default build id. A default/0 value will return the entire graph.
-    int32 max_depth = 3;
-}
-message GetWorkerBuildIdOrderingResponse {
-    // The currently established default version
-    temporal.api.taskqueue.v1.VersionIdNode current_default = 1;
-    // Other current latest-compatible versions who are not the overall default. These are the
-    // versions that will be used when generating new tasks by following the graph from the
-    // version of the last task out to a leaf.
-    repeated temporal.api.taskqueue.v1.VersionIdNode compatible_leaves = 2;
+    // Limits how many compatible sets will be returned. Specify 1 to only return the current
+    // default major version set. 0 returns all sets.
+    int32 max_sets = 3;
+    // If set, the response will include information about worker versions which are ready to be
+    // retired.
+    bool include_retirement_candidates = 4;
+    // If set, the response will include information about which versions have open workflows, and
+    // whether or not there are currently polling workers who are compatible with those versions.
+    bool include_poller_compatibility = 5;
+}
+message GetWorkerBuildIdCompatibilityResponse {
+    // Major version sets, in order from oldest to newest. The last element of the list will always
+    // be the current default major version. IE: New workflows will target the most recent version
+    // in that version set.
+    //
+    // There may be fewer sets returned than exist, if the request chose to limit this response.
+    repeated temporal.api.taskqueue.v1.CompatibleVersionSet major_version_sets = 1;
+
+    message RetirementCandidate {
+        // The worker build id which is ready for retirement
+        string build_id = 1;
+        // If true, there are no open *or* closed workflows, meaning there is no reason at all
+        // to keep the worker alive, not even to service queries on closed workflows. If not true,
+        // then there are no open workflows, but some closed ones.
+        bool all_workflows_are_archived = 2;
+        // Currently polling workers who match the build id ready for retirement
+        repeated temporal.api.taskqueue.v1.PollerInfo pollers = 3;
+    }
+
+    // A list of workers who are still live and polling the task queue, but may no longer be needed
+    // to make progress on open workflows.
+    repeated RetirementCandidate retirement_candidates = 2;
+
+    message VersionsWithCompatiblePollers {
+        // The latest build id which completed a workflow task on some open workflow
+        string most_recent_build_id = 1;
+        // Currently polling workers who are compatible with `most_recent_build_id`.
+        repeated temporal.api.taskqueue.v1.PollerInfo pollers = 2;
+    }
+
+    // A list of versions and pollers who are capable of processing tasks at that version (if any)
+    // for which there are currently open workflows.
+    repeated VersionsWithCompatiblePollers active_versions_and_pollers = 3;
 }
 
 // (-- api-linter: core::0134=disabled
@@ -1197,3 +1272,25 @@ message ListBatchOperationsResponse {
     repeated temporal.api.batch.v1.BatchOperationInfo operation_info = 1;
     bytes next_page_token = 2;
 }
+
+message PollWorkflowExecutionUpdateRequest {
+    // The namespace of the workflow execution to which the update was
+    // originally issued.
+    string namespace = 1;
+    // The update reference returned in the initial
+    // UpdateWorkflowExecutionResponse
+    temporal.api.update.v1.UpdateRef update_ref = 2;
+    // The identity of the worker/client who is polling this update outcome
+    string identity = 3;
+    // Describes when this poll request should return a response
+    temporal.api.update.v1.WaitPolicy wait_policy = 4;
+}
+
+message PollWorkflowExecutionUpdateResponse {
+    // The outcome of the update if and only if the update has completed. If
+    // this response is being returned before the update has completed (e.g. due
+    // to the specification of a wait policy that only waits on
+    // UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ACCEPTED) then this field will
+    // not be set.
+    temporal.api.update.v1.Outcome outcome = 1;
+}

package/sdk-core/protos/api_upstream/temporal/api/workflowservice/v1/service.proto

@@ -380,16 +380,18 @@ service WorkflowService {
     rpc ListSchedules (ListSchedulesRequest) returns (ListSchedulesResponse) {
     }
 
-    // Allows users to specify a graph of worker build id based versions on a
-    // per task queue basis. Versions are ordered, and may be either compatible
-    // with some extant version, or a new incompatible version.
+    // Allows users to specify sets of worker build id versions on a per task queue basis. Versions
+    // are ordered, and may be either compatible with some extant version, or a new incompatible
+    // version, forming sets of ids which are incompatible with each other, but whose contained
+    // members are compatible with one another.
+    //
     // (-- api-linter: core::0134::response-message-name=disabled
-    //     aip.dev/not-precedent: UpdateWorkerBuildIdOrdering RPC doesn't follow Google API format. --)
+    //     aip.dev/not-precedent: UpdateWorkerBuildIdCompatibility RPC doesn't follow Google API format. --)
     // (-- api-linter: core::0134::method-signature=disabled
-    //     aip.dev/not-precedent: UpdateWorkerBuildIdOrdering RPC doesn't follow Google API format. --)
-    rpc UpdateWorkerBuildIdOrdering (UpdateWorkerBuildIdOrderingRequest) returns (UpdateWorkerBuildIdOrderingResponse) {}
-    // Fetches the worker build id versioning graph for some task queue.
-    rpc GetWorkerBuildIdOrdering (GetWorkerBuildIdOrderingRequest) returns (GetWorkerBuildIdOrderingResponse) {}
+    //     aip.dev/not-precedent: UpdateWorkerBuildIdCompatibility RPC doesn't follow Google API format. --)
+    rpc UpdateWorkerBuildIdCompatibility (UpdateWorkerBuildIdCompatibilityRequest) returns (UpdateWorkerBuildIdCompatibilityResponse) {}
+    // Fetches the worker build id versioning sets for some task queue and related metadata.
+    rpc GetWorkerBuildIdCompatibility (GetWorkerBuildIdCompatibilityRequest) returns (GetWorkerBuildIdCompatibilityResponse) {}
 
     // Invokes the specified update function on user workflow code.
     // (-- api-linter: core::0134=disabled
@@ -397,6 +399,15 @@ service WorkflowService {
     rpc UpdateWorkflowExecution(UpdateWorkflowExecutionRequest) returns (UpdateWorkflowExecutionResponse) {
     }
 
+    // Polls a workflow execution for the outcome of a workflow execution update
+    // previously issued through the UpdateWorkflowExecution RPC. The effective
+    // timeout on this call will be shorter of the the caller-supplied gRPC
+    // timeout and the server's configured long-poll timeout.
+    // (-- api-linter: core::0134=disabled
+    //     aip.dev/not-precedent: UpdateWorkflowExecution doesn't follow Google API format --)
+    rpc PollWorkflowExecutionUpdate(PollWorkflowExecutionUpdateRequest) returns (PollWorkflowExecutionUpdateResponse){
+    }
+
     // StartBatchOperation starts a new batch operation
     rpc StartBatchOperation(StartBatchOperationRequest) returns (StartBatchOperationResponse) {
     }

package/sdk-core/test-utils/src/lib.rs

@@ -22,7 +22,8 @@ use std::{
     time::Duration,
 };
 use temporal_client::{
-    Client, RetryClient, WorkflowClientTrait, WorkflowExecutionInfo, WorkflowOptions,
+    Client, ClientTlsConfig, RetryClient, TlsConfig, WorkflowClientTrait, WorkflowExecutionInfo,
+    WorkflowOptions,
 };
 use temporal_sdk::{
     interceptors::{FailOnNondeterminismInterceptor, WorkerInterceptor},
@@ -34,8 +35,8 @@ use temporal_sdk_core::{
     replay::HistoryForReplay,
     ClientOptions, ClientOptionsBuilder, CoreRuntime, WorkerConfig, WorkerConfigBuilder,
 };
-use temporal_sdk_core_api::errors::{PollActivityError, PollWfError};
 use temporal_sdk_core_api::{
+    errors::{PollActivityError, PollWfError},
     telemetry::{
         Logger, MetricsExporter, OtelCollectorOptions, TelemetryOptions, TelemetryOptionsBuilder,
         TraceExportConfig, TraceExporter,
@@ -60,6 +61,7 @@ pub const NAMESPACE: &str = "default";
 pub const TEST_Q: &str = "q";
 /// The env var used to specify where the integ tests should point
 pub const INTEG_SERVER_TARGET_ENV_VAR: &str = "TEMPORAL_SERVICE_ADDRESS";
+pub const INTEG_USE_TLS_ENV_VAR: &str = "TEMPORAL_USE_TLS";
 /// This env var is set (to any value) if temporal CLI dev server is in use
 pub const INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR: &str = "INTEG_TEMPORAL_DEV_SERVER_ON";
 /// This env var is set (to any value) if the test server is in use
@@ -533,13 +535,33 @@ pub fn get_integ_server_options() -> ClientOptions {
         Err(_) => "http://localhost:7233".to_owned(),
     };
     let url = Url::try_from(&*temporal_server_address).unwrap();
-    ClientOptionsBuilder::default()
-        .identity("integ_tester".to_string())
+    let mut cb = ClientOptionsBuilder::default();
+    cb.identity("integ_tester".to_string())
         .target_url(url)
         .client_name("temporal-core".to_string())
-        .client_version("0.1.0".to_string())
-        .build()
-        .unwrap()
+        .client_version("0.1.0".to_string());
+    if let Some(tls) = get_integ_tls_config() {
+        cb.tls_cfg(tls);
+    };
+    cb.build().unwrap()
+}
+
+pub fn get_integ_tls_config() -> Option<TlsConfig> {
+    if env::var(INTEG_USE_TLS_ENV_VAR).is_ok() {
+        let root = std::fs::read("../.cloud_certs/ca.pem").unwrap();
+        let client_cert = std::fs::read("../.cloud_certs/client.pem").unwrap();
+        let client_private_key = std::fs::read("../.cloud_certs/client.key").unwrap();
+        Some(TlsConfig {
+            server_root_ca_cert: Some(root),
+            domain: None,
+            client_tls_config: Some(ClientTlsConfig {
+                client_cert,
+                client_private_key,
+            }),
+        })
+    } else {
+        None
+    }
 }
 
 pub fn get_integ_telem_options() -> TelemetryOptions {

package/sdk-core/tests/integ_tests/activity_functions.rs

@@ -0,0 +1,5 @@
+use temporal_sdk::ActContext;
+
+pub async fn echo(_ctx: ActContext, e: String) -> anyhow::Result<String> {
+    Ok(e)
+}

package/sdk-core/tests/integ_tests/workflow_tests/activities.rs

@@ -1,3 +1,4 @@
+use crate::integ_tests::activity_functions::echo;
 use anyhow::anyhow;
 use assert_matches::assert_matches;
 use futures_util::future::join_all;
@@ -52,10 +53,7 @@ async fn one_activity() {
     let mut worker = starter.worker().await;
     let client = starter.get_client().await;
     worker.register_wf(wf_name.to_owned(), one_activity_wf);
-    worker.register_activity(
-        "echo_activity",
-        |_ctx: ActContext, echo_me: String| async move { Ok(echo_me) },
-    );
+    worker.register_activity("echo_activity", echo);
 
     let run_id = worker
         .submit_wf(

package/sdk-core/tests/integ_tests/workflow_tests/determinism.rs

@@ -2,7 +2,6 @@ use std::{
     sync::atomic::{AtomicUsize, Ordering},
     time::Duration,
 };
-
 use temporal_sdk::{ActivityOptions, WfContext, WorkflowResult};
 use temporal_sdk_core_test_utils::CoreWfStarter;
 

package/sdk-core/tests/integ_tests/workflow_tests/local_activities.rs

@@ -1,3 +1,4 @@
+use crate::integ_tests::activity_functions::echo;
 use anyhow::anyhow;
 use futures::future::join_all;
 use std::{
@@ -12,9 +13,10 @@ use temporal_sdk::{
 use temporal_sdk_core::replay::HistoryForReplay;
 use temporal_sdk_core_protos::{
     coresdk::{
-        workflow_commands::workflow_command::Variant, workflow_commands::ActivityCancellationType,
-        workflow_completion, workflow_completion::workflow_activation_completion,
-        workflow_completion::WorkflowActivationCompletion, AsJsonPayloadExt,
+        workflow_commands::{workflow_command::Variant, ActivityCancellationType},
+        workflow_completion,
+        workflow_completion::{workflow_activation_completion, WorkflowActivationCompletion},
+        AsJsonPayloadExt,
     },
     temporal::api::{common::v1::RetryPolicy, enums::v1::TimeoutType},
     TestHistoryBuilder,
@@ -25,10 +27,6 @@ use temporal_sdk_core_test_utils::{
 };
 use tokio_util::sync::CancellationToken;
 
-pub async fn echo(_ctx: ActContext, e: String) -> anyhow::Result<String> {
-    Ok(e)
-}
-
 pub async fn one_local_activity_wf(ctx: WfContext) -> WorkflowResult<()> {
     let initial_workflow_time = ctx.workflow_time().expect("Workflow time should be set");
     ctx.local_activity(LocalActivityOptions {

package/sdk-core/tests/integ_tests/workflow_tests.rs

@@ -15,6 +15,7 @@ mod stickyness;
 mod timers;
 mod upsert_search_attrs;
 
+use crate::integ_tests::activity_functions::echo;
 use assert_matches::assert_matches;
 use futures::{channel::mpsc::UnboundedReceiver, future, SinkExt, StreamExt};
 use std::{
@@ -26,9 +27,7 @@ use std::{
     time::Duration,
 };
 use temporal_client::{WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{
-    interceptors::WorkerInterceptor, ActContext, ActivityOptions, WfContext, WorkflowResult,
-};
+use temporal_sdk::{interceptors::WorkerInterceptor, ActivityOptions, WfContext, WorkflowResult};
 use temporal_sdk_core::replay::HistoryForReplay;
 use temporal_sdk_core_api::{errors::PollWfError, Worker};
 use temporal_sdk_core_protos::{
@@ -564,10 +563,7 @@ async fn slow_completes_with_small_cache() {
         }
         Ok(().into())
     });
-    worker.register_activity(
-        "echo_activity",
-        |_ctx: ActContext, echo_me: String| async move { Ok(echo_me) },
-    );
+    worker.register_activity("echo_activity", echo);
     for i in 0..20 {
         worker
             .submit_wf(

package/sdk-core/tests/main.rs

@@ -7,6 +7,7 @@ extern crate temporal_sdk_core_test_utils;
 
 #[cfg(test)]
 mod integ_tests {
+    mod activity_functions;
     mod client_tests;
     mod ephemeral_server_tests;
     mod heartbeat_tests;
@@ -25,7 +26,7 @@ mod integ_tests {
     use temporal_sdk_core_api::worker::WorkerConfigBuilder;
     use temporal_sdk_core_protos::temporal::api::workflowservice::v1::ListNamespacesRequest;
     use temporal_sdk_core_test_utils::{
-        get_integ_server_options, get_integ_telem_options, NAMESPACE,
+        get_integ_server_options, get_integ_telem_options, init_integ_telem,
     };
     use url::Url;
 
@@ -58,35 +59,23 @@ mod integ_tests {
             .await;
     }
 
-    // TODO: Currently ignored because starting up the docker image with TLS requires some hoop
-    //  jumping. We should upgrade CI to be able to do that but this was manually run against
-    //  https://github.com/temporalio/customization-samples/tree/master/tls/tls-simple
+    // Manually run to verify tls works against cloud. You will need certs in place in the
+    // indicated directory.
     #[tokio::test]
     #[ignore]
     async fn tls_test() {
-        // Load certs/keys
-        let root = tokio::fs::read(
-            "/home/sushi/dev/temporal/customization-samples/tls/tls-simple/certs/ca.cert",
-        )
-        .await
-        .unwrap();
-        let client_cert = tokio::fs::read(
-            "/home/sushi/dev/temporal/customization-samples/tls/tls-simple/certs/client.pem",
-        )
-        .await
-        .unwrap();
-        let client_private_key = tokio::fs::read(
-            "/home/sushi/dev/temporal/customization-samples/tls/tls-simple/certs/client.key",
-        )
-        .await
-        .unwrap();
+        init_integ_telem();
+        let root = tokio::fs::read("../.cloud_certs/ca.pem").await.unwrap();
+        let client_cert = tokio::fs::read("../.cloud_certs/client.pem").await.unwrap();
+        let client_private_key = tokio::fs::read("../.cloud_certs/client.key").await.unwrap();
         let sgo = ClientOptionsBuilder::default()
-            .target_url(Url::from_str("https://localhost:7233").unwrap())
+            .target_url(Url::from_str("https://spencer.temporal-dev.tmprl.cloud:7233").unwrap())
             .client_name("tls_tester")
             .client_version("clientver")
             .tls_cfg(TlsConfig {
                 server_root_ca_cert: Some(root),
-                domain: Some("tls-sample".to_string()),
+                // Not necessary, but illustrates functionality for people using proxies, etc.
+                domain: Some("spencer.temporal-dev.tmprl.cloud".to_string()),
                 client_tls_config: Some(ClientTlsConfig {
                     client_cert,
                     client_private_key,
@@ -95,9 +84,12 @@ mod integ_tests {
             .build()
             .unwrap();
         let con = sgo
-            .connect(NAMESPACE.to_string(), None, None)
+            .connect("spencer.temporal-dev".to_string(), None, None)
             .await
             .unwrap();
-        con.list_namespaces().await.unwrap();
+        dbg!(con
+            .list_workflow_executions(100, vec![], "".to_string())
+            .await
+            .unwrap());
     }
 }