@temporalio/core-bridge 1.13.0 → 1.13.2

package/sdk-core/sdk-core-protos/src/lib.rs

@@ -5,11 +5,15 @@
 pub mod constants;
 pub mod utilities;
 
+#[cfg(feature = "test-utilities")]
+pub mod canned_histories;
 #[cfg(feature = "history_builders")]
 mod history_builder;
 #[cfg(feature = "history_builders")]
 mod history_info;
 mod task_token;
+#[cfg(feature = "test-utilities")]
+pub mod test_utils;
 
 #[cfg(feature = "history_builders")]
 pub use history_builder::{
@@ -23,6 +27,8 @@ pub use task_token::TaskToken;
 pub static ENCODING_PAYLOAD_KEY: &str = "encoding";
 pub static JSON_ENCODING_VAL: &str = "json/plain";
 pub static PATCHED_MARKER_DETAILS_KEY: &str = "patch-data";
+/// The search attribute key used when registering change versions
+pub static VERSION_SEARCH_ATTR_KEY: &str = "TemporalChangeVersion";
 
 #[allow(
     clippy::large_enum_variant,
@@ -39,7 +45,7 @@ pub mod coresdk {
     use crate::{
         ENCODING_PAYLOAD_KEY, JSON_ENCODING_VAL,
         temporal::api::{
-            common::v1::{Payload, Payloads, WorkflowExecution},
+            common::v1::{Payload, Payloads, RetryPolicy, WorkflowExecution},
             enums::v1::{
                 ApplicationErrorCategory, TimeoutType, VersioningBehavior, WorkflowTaskFailedCause,
             },
@@ -390,7 +396,7 @@ pub mod coresdk {
     }
 
     pub mod external_data {
-        use prost_wkt_types::{Duration, Timestamp};
+        use prost_types::{Duration, Timestamp};
         use serde::{Deserialize, Deserializer, Serialize, Serializer};
         tonic::include_proto!("coresdk.external_data");
 
@@ -475,6 +481,7 @@ pub mod coresdk {
                 FromPayloadsExt,
                 activity_result::{ActivityResolution, activity_resolution},
                 common::NamespacedWorkflowExecution,
+                fix_retry_policy,
                 workflow_activation::remove_from_cache::EvictionReason,
             },
             temporal::api::{
@@ -487,7 +494,7 @@ pub mod coresdk {
                 query::v1::WorkflowQuery,
             },
         };
-        use prost_wkt_types::Timestamp;
+        use prost_types::Timestamp;
         use std::fmt::{Display, Formatter};
 
         tonic::include_proto!("coresdk.workflow_activation");
@@ -512,6 +519,7 @@ pub mod coresdk {
                 history_size_bytes: 0,
                 continue_as_new_suggested: false,
                 deployment_version_for_current_task: None,
+                last_sdk_version: String::new(),
             }
         }
 
@@ -739,7 +747,7 @@ pub mod coresdk {
                 continued_failure: attrs.continued_failure,
                 last_completion_result: attrs.last_completion_result,
                 first_execution_run_id: attrs.first_execution_run_id,
-                retry_policy: attrs.retry_policy,
+                retry_policy: attrs.retry_policy.map(fix_retry_policy),
                 attempt: attrs.attempt,
                 cron_schedule: attrs.cron_schedule,
                 workflow_execution_expiration_time: attrs.workflow_execution_expiration_time,
@@ -1292,7 +1300,7 @@ pub mod coresdk {
                         schedule_to_close_timeout: r.schedule_to_close_timeout,
                         start_to_close_timeout: r.start_to_close_timeout,
                         heartbeat_timeout: r.heartbeat_timeout,
-                        retry_policy: r.retry_policy,
+                        retry_policy: r.retry_policy.map(fix_retry_policy),
                         priority: r.priority,
                         is_local: false,
                     },
@@ -1572,6 +1580,15 @@ pub mod coresdk {
             }
         }
     }
+
+    /// If initial_interval is missing, fills it with zero value to prevent crashes
+    /// (lang assumes that RetryPolicy always has initial_interval set).
+    fn fix_retry_policy(mut retry_policy: RetryPolicy) -> RetryPolicy {
+        if retry_policy.initial_interval.is_none() {
+            retry_policy.initial_interval = Default::default();
+        }
+        retry_policy
+    }
 }
 
 // No need to lint these
@@ -2135,8 +2152,7 @@ pub mod temporal {
                     enums::v1::EventType, history::v1::history_event::Attributes,
                 };
                 use anyhow::bail;
-                use prost::alloc::fmt::Formatter;
-                use std::fmt::Display;
+                use std::fmt::{Display, Formatter};
 
                 tonic::include_proto!("temporal.api.history.v1");
 
@@ -2677,8 +2693,8 @@ pub mod temporal {
                 }
 
                 fn elapsed_between_prost_times(
-                    from: prost_wkt_types::Timestamp,
-                    to: prost_wkt_types::Timestamp,
+                    from: prost_types::Timestamp,
+                    to: prost_types::Timestamp,
                 ) -> Option<Option<Duration>> {
                     let from: Result<SystemTime, _> = from.try_into();
                     let to: Result<SystemTime, _> = to.try_into();

package/sdk-core/sdk-core-protos/src/test_utils.rs

@@ -0,0 +1,89 @@
+//! Test utilities for creating workflow commands and histories
+//! Only available when the test-utilities feature is enabled
+
+use crate::{
+    DEFAULT_ACTIVITY_TYPE,
+    coresdk::workflow_commands::{
+        ActivityCancellationType, QueryResult, QuerySuccess, ScheduleActivity,
+        ScheduleLocalActivity, StartTimer, workflow_command,
+    },
+    temporal::api::common::v1::Payload,
+};
+use std::time::Duration;
+
+/// Convenience macro for creating prost Duration from std::time::Duration
+#[macro_export]
+macro_rules! prost_dur {
+    ($dur_call:ident $args:tt) => {
+        std::time::Duration::$dur_call$args
+            .try_into()
+            .expect("test duration fits")
+    };
+}
+
+/// Create a start timer command for use in tests
+pub fn start_timer_cmd(seq: u32, duration: Duration) -> workflow_command::Variant {
+    StartTimer {
+        seq,
+        start_to_fire_timeout: Some(duration.try_into().expect("duration fits")),
+    }
+    .into()
+}
+
+/// Create a schedule activity command for use in tests
+pub fn schedule_activity_cmd(
+    seq: u32,
+    task_q: &str,
+    activity_id: &str,
+    cancellation_type: ActivityCancellationType,
+    activity_timeout: Duration,
+    heartbeat_timeout: Duration,
+) -> workflow_command::Variant {
+    ScheduleActivity {
+        seq,
+        activity_id: activity_id.to_string(),
+        activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
+        task_queue: task_q.to_owned(),
+        schedule_to_start_timeout: Some(activity_timeout.try_into().expect("duration fits")),
+        start_to_close_timeout: Some(activity_timeout.try_into().expect("duration fits")),
+        schedule_to_close_timeout: Some(activity_timeout.try_into().expect("duration fits")),
+        heartbeat_timeout: Some(heartbeat_timeout.try_into().expect("duration fits")),
+        cancellation_type: cancellation_type as i32,
+        ..Default::default()
+    }
+    .into()
+}
+
+/// Create a schedule local activity command for use in tests
+pub fn schedule_local_activity_cmd(
+    seq: u32,
+    activity_id: &str,
+    cancellation_type: ActivityCancellationType,
+    activity_timeout: Duration,
+) -> workflow_command::Variant {
+    ScheduleLocalActivity {
+        seq,
+        activity_id: activity_id.to_string(),
+        activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
+        schedule_to_start_timeout: Some(activity_timeout.try_into().expect("duration fits")),
+        start_to_close_timeout: Some(activity_timeout.try_into().expect("duration fits")),
+        schedule_to_close_timeout: Some(activity_timeout.try_into().expect("duration fits")),
+        cancellation_type: cancellation_type as i32,
+        ..Default::default()
+    }
+    .into()
+}
+
+/// Create a successful query response command for use in tests
+pub fn query_ok(id: impl Into<String>, response: impl Into<Payload>) -> workflow_command::Variant {
+    QueryResult {
+        query_id: id.into(),
+        variant: Some(
+            QuerySuccess {
+                response: Some(response.into()),
+            }
+            .into(),
+        ),
+    }
+    .into()
+}

package/sdk-core/sdk-core-protos/src/utilities.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use prost::{EncodeError, Message};
 
 pub trait TryIntoOrNone<F, T> {
@@ -18,11 +20,18 @@ where
 /// Use to encode an message into a proto `Any`.
 ///
 /// Delete this once `prost_wkt_types` supports `prost` `0.12.x` which has built-in any packing.
-pub fn pack_any<T: Message>(
-    type_url: String,
-    msg: &T,
-) -> Result<prost_wkt_types::Any, EncodeError> {
+pub fn pack_any<T: Message>(type_url: String, msg: &T) -> Result<prost_types::Any, EncodeError> {
     let mut value = Vec::new();
     Message::encode(msg, &mut value)?;
-    Ok(prost_wkt_types::Any { type_url, value })
+    Ok(prost_types::Any { type_url, value })
+}
+
+/// Given a header map, lowercase all the keys and return it as a new map.
+/// Any keys that are duplicated after lowercasing will clobber each other in undefined ordering.
+pub fn normalize_http_headers(headers: HashMap<String, String>) -> HashMap<String, String> {
+    let mut new_headers = HashMap::new();
+    for (header_key, val) in headers.into_iter() {
+        new_headers.insert(header_key.to_lowercase(), val);
+    }
+    new_headers
 }

package/sdk-core/tests/c_bridge_smoke_test.c

@@ -0,0 +1,10 @@
+#include "temporal-sdk-core-c-bridge.h"
+#include <stdio.h>
+
+int main(void) {
+    // Just do something simple to confirm the bridge works
+    struct TemporalCoreCancellationToken *tok = temporal_core_cancellation_token_new();
+    temporal_core_cancellation_token_free(tok);
+    printf("C bridge smoke test passed!\n");
+    return 0;
+}

package/sdk-core/tests/cloud_tests.rs

@@ -1,8 +1,11 @@
-use temporal_client::WorkflowClientTrait;
-use temporal_sdk_core_test_utils::get_cloud_client;
-
+// All non-main.rs tests ignore dead common code so that the linter doesn't complain about about it.
+#[allow(dead_code)]
+mod common;
 mod shared_tests;
 
+use common::get_cloud_client;
+use temporal_client::WorkflowClientTrait;
+
 #[tokio::test]
 async fn tls_test() {
     let con = get_cloud_client().await;
@@ -16,8 +19,7 @@ async fn grpc_message_too_large_test() {
     shared_tests::grpc_message_too_large().await
 }
 
-// Needs https://github.com/temporalio/temporal/pull/8143 to be rolled out in cloud to pass
-// #[tokio::test]
-// async fn priority_values_sent_to_server() {
-//     shared_tests::priority::priority_values_sent_to_server().await
-// }
+#[tokio::test]
+async fn priority_values_sent_to_server() {
+    shared_tests::priority::priority_values_sent_to_server().await
+}

package/sdk-core/tests/common/http_proxy.rs

@@ -0,0 +1,134 @@
+use bytes::Bytes;
+use http_body_util::Empty;
+use hyper::{
+    Request, Response, StatusCode, body::Incoming, server::conn::http1, service::service_fn,
+};
+use hyper_util::rt::TokioIo;
+use std::{
+    io,
+    sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    },
+};
+use temporal_client::proxy::ProxyStream;
+#[cfg(unix)]
+use tokio::net::UnixListener;
+use tokio::{
+    net::{TcpListener, TcpStream},
+    sync::oneshot,
+};
+
+pub(crate) struct HttpProxy {
+    proxy_hits: Arc<AtomicUsize>,
+    shutdown_tx: oneshot::Sender<()>,
+}
+impl HttpProxy {
+    pub(crate) fn spawn_tcp(listener: TcpListener) -> Self {
+        Self::spawn(ProxyListener::Tcp(listener))
+    }
+
+    #[cfg(unix)]
+    pub(crate) fn spawn_unix(listener: UnixListener) -> Self {
+        Self::spawn(ProxyListener::Unix(listener))
+    }
+
+    fn spawn(listener: ProxyListener) -> Self {
+        let (shutdown_tx, mut shutdown_rx) = oneshot::channel::<()>();
+        let proxy_hits = Arc::new(AtomicUsize::new(0));
+        let proxy_hits_cloned = proxy_hits.clone();
+        tokio::spawn(async move {
+            loop {
+                let proxy_hits_cloned = proxy_hits_cloned.clone();
+                tokio::select! {
+                    _ = &mut shutdown_rx => break,
+                    stream = listener.accept() => {
+                        let stream = match stream {
+                            Ok(stream) => stream,
+                            Err(e) => { println!("Proxy accept error: {e}"); continue; }
+                        };
+                        tokio::spawn(async move {
+                            if let Err(e) = http1::Builder::new()
+                                .serve_connection(
+                                    TokioIo::new(stream),
+                                    service_fn(move |req| handle_connect(req, proxy_hits_cloned.clone())),
+                                )
+                                .with_upgrades()
+                                .await
+                            {
+                                println!("Proxy conn error: {e}");
+                            }
+                        });
+                    }
+                }
+            }
+        });
+        Self {
+            proxy_hits,
+            shutdown_tx,
+        }
+    }
+
+    pub(crate) fn hit_count(&self) -> usize {
+        self.proxy_hits.load(Ordering::SeqCst)
+    }
+
+    /// Returns before shutdown occurs
+    pub(crate) fn shutdown(self) {
+        let _ = self.shutdown_tx.send(());
+    }
+}
+
+async fn handle_connect(
+    req: Request<Incoming>,
+    counter: Arc<AtomicUsize>,
+) -> Result<Response<Empty<Bytes>>, hyper::Error> {
+    if req.method() == hyper::Method::CONNECT {
+        // Increment atomic counter
+        counter.fetch_add(1, Ordering::SeqCst);
+
+        // Tell the client the tunnel is established
+        tokio::spawn(async move {
+            if let Some(addr) = req.uri().authority().map(|a| a.as_str()) {
+                match TcpStream::connect(addr).await {
+                    Ok(mut server_stream) => match hyper::upgrade::on(req).await {
+                        Ok(upgraded) => {
+                            let mut upgraded = TokioIo::new(upgraded);
+                            let _ =
+                                tokio::io::copy_bidirectional(&mut upgraded, &mut server_stream)
+                                    .await;
+                        }
+                        Err(err) => println!("Upgrade failed: {err}"),
+                    },
+                    Err(e) => println!("Failed to connect to {addr}: {e}"),
+                }
+            }
+        });
+
+        Ok(Response::builder()
+            .status(StatusCode::OK)
+            .body(Empty::new())
+            .unwrap())
+    } else {
+        Ok(Response::builder()
+            .status(StatusCode::METHOD_NOT_ALLOWED)
+            .body(Empty::new())
+            .unwrap())
+    }
+}
+
+enum ProxyListener {
+    Tcp(TcpListener),
+    #[cfg(unix)]
+    Unix(UnixListener),
+}
+
+impl ProxyListener {
+    async fn accept(&self) -> io::Result<ProxyStream> {
+        match self {
+            ProxyListener::Tcp(tcp) => tcp.accept().await.map(|(s, _)| ProxyStream::Tcp(s)),
+            #[cfg(unix)]
+            ProxyListener::Unix(unix) => unix.accept().await.map(|(s, _)| ProxyStream::Unix(s)),
+        }
+    }
+}