temporalio 0.1.1 → 0.2.0

data/bridge/sdk-core/core/src/internal_flags.rs

@@ -1,136 +0,0 @@
-//! Utilities for and tracking of internal versions which alter history in incompatible ways
-//! so that we can use older code paths for workflows executed on older core versions.
-
-use std::collections::{BTreeSet, HashSet};
-use temporal_sdk_core_protos::temporal::api::{
-    history::v1::WorkflowTaskCompletedEventAttributes, sdk::v1::WorkflowTaskCompletedMetadata,
-    workflowservice::v1::get_system_info_response,
-};
-
-/// This enumeration contains internal flags that may result in incompatible history changes with
-/// older workflows, or other breaking changes.
-///
-/// When a flag has existed long enough the version it was introduced in is no longer supported, it
-/// may be removed from the enum. *Importantly*, all variants must be given explicit values, such
-/// that removing older variants does not create any change in existing values. Removed flag
-/// variants must be reserved forever (a-la protobuf), and should be called out in a comment.
-#[repr(u32)]
-#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Clone, Debug)]
-pub(crate) enum CoreInternalFlags {
-    /// In this flag, additional checks were added to a number of state machines to ensure that
-    /// the ID and type of activities, local activities, and child workflows match during replay.
-    IdAndTypeDeterminismChecks = 1,
-    /// We received a value higher than this code can understand.
-    TooHigh = u32::MAX,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct InternalFlags {
-    enabled: bool,
-    core: BTreeSet<CoreInternalFlags>,
-    lang: BTreeSet<u32>,
-    core_since_last_complete: HashSet<CoreInternalFlags>,
-    lang_since_last_complete: HashSet<u32>,
-}
-
-impl InternalFlags {
-    pub fn new(server_capabilities: &get_system_info_response::Capabilities) -> Self {
-        Self {
-            enabled: server_capabilities.sdk_metadata,
-            core: Default::default(),
-            lang: Default::default(),
-            core_since_last_complete: Default::default(),
-            lang_since_last_complete: Default::default(),
-        }
-    }
-
-    pub fn add_from_complete(&mut self, e: &WorkflowTaskCompletedEventAttributes) {
-        if !self.enabled {
-            return;
-        }
-
-        if let Some(metadata) = e.sdk_metadata.as_ref() {
-            self.core.extend(
-                metadata
-                    .core_used_flags
-                    .iter()
-                    .map(|u| CoreInternalFlags::from_u32(*u)),
-            );
-            self.lang.extend(metadata.lang_used_flags.iter());
-        }
-    }
-
-    pub fn add_lang_used(&mut self, flags: impl IntoIterator<Item = u32>) {
-        if !self.enabled {
-            return;
-        }
-
-        self.lang_since_last_complete.extend(flags.into_iter());
-    }
-
-    /// Returns true if this flag may currently be used. If `should_record` is true, always returns
-    /// true and records the flag as being used, for taking later via
-    /// [Self::gather_for_wft_complete].
-    pub fn try_use(&mut self, core_patch: CoreInternalFlags, should_record: bool) -> bool {
-        if !self.enabled {
-            // If the server does not support the metadata field, we must assume
-            return false;
-        }
-
-        if should_record {
-            self.core_since_last_complete.insert(core_patch);
-            true
-        } else {
-            self.core.contains(&core_patch)
-        }
-    }
-
-    /// Wipes the recorded flags used during the current WFT and returns a partially filled
-    /// sdk metadata message that can be combined with any existing data before sending the WFT
-    /// complete
-    pub fn gather_for_wft_complete(&mut self) -> WorkflowTaskCompletedMetadata {
-        WorkflowTaskCompletedMetadata {
-            core_used_flags: self
-                .core_since_last_complete
-                .drain()
-                .map(|p| p as u32)
-                .collect(),
-            lang_used_flags: self.lang_since_last_complete.drain().collect(),
-        }
-    }
-
-    pub fn all_lang(&self) -> &BTreeSet<u32> {
-        &self.lang
-    }
-}
-
-impl CoreInternalFlags {
-    fn from_u32(v: u32) -> Self {
-        match v {
-            1 => Self::IdAndTypeDeterminismChecks,
-            _ => Self::TooHigh,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use temporal_sdk_core_protos::temporal::api::workflowservice::v1::get_system_info_response::Capabilities;
-
-    #[test]
-    fn disabled_in_capabilities_disables() {
-        let mut f = InternalFlags::new(&Capabilities::default());
-        f.add_lang_used([1]);
-        f.add_from_complete(&WorkflowTaskCompletedEventAttributes {
-            sdk_metadata: Some(WorkflowTaskCompletedMetadata {
-                core_used_flags: vec![1],
-                lang_used_flags: vec![],
-            }),
-            ..Default::default()
-        });
-        let gathered = f.gather_for_wft_complete();
-        assert_matches!(gathered.core_used_flags.as_slice(), &[]);
-        assert_matches!(gathered.lang_used_flags.as_slice(), &[]);
-    }
-}

data/bridge/sdk-core/core/src/lib.rs

@@ -1,289 +0,0 @@
-#![warn(missing_docs)] // error if there are missing docs
-#![allow(clippy::upper_case_acronyms)]
-
-//! This crate provides a basis for creating new Temporal SDKs without completely starting from
-//! scratch
-
-#[cfg(test)]
-#[macro_use]
-pub extern crate assert_matches;
-#[macro_use]
-extern crate tracing;
-extern crate core;
-
-mod abstractions;
-pub mod ephemeral_server;
-mod internal_flags;
-mod pollers;
-mod protosext;
-pub mod replay;
-pub(crate) mod retry_logic;
-pub mod telemetry;
-mod worker;
-
-#[cfg(test)]
-mod core_tests;
-#[cfg(test)]
-#[macro_use]
-mod test_help;
-
-pub(crate) use temporal_sdk_core_api::errors;
-
-pub use pollers::{
-    Client, ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryClient, RetryConfig,
-    TlsConfig, WorkflowClientTrait,
-};
-pub use temporal_sdk_core_api as api;
-pub use temporal_sdk_core_protos as protos;
-pub use temporal_sdk_core_protos::TaskToken;
-pub use url::Url;
-#[cfg(feature = "save_wf_inputs")]
-pub use worker::replay_wf_state_inputs;
-pub use worker::{Worker, WorkerConfig, WorkerConfigBuilder};
-
-use crate::{
-    replay::{mock_client_from_histories, Historator, HistoryForReplay},
-    telemetry::{
-        metrics::{MetricsContext, TemporalMeter},
-        remove_trace_subscriber_for_current_thread, set_trace_subscriber_for_current_thread,
-        telemetry_init, TelemetryInstance,
-    },
-    worker::client::WorkerClientBag,
-};
-use futures::Stream;
-use std::sync::Arc;
-use temporal_client::{ConfiguredClient, TemporalServiceClientWithMetrics};
-use temporal_sdk_core_api::{
-    errors::{CompleteActivityError, PollActivityError, PollWfError},
-    telemetry::TelemetryOptions,
-    Worker as WorkerTrait,
-};
-use temporal_sdk_core_protos::coresdk::ActivityHeartbeat;
-
-/// Initialize a worker bound to a task queue.
-///
-/// You will need to have already initialized a [CoreRuntime] which will be used for this worker.
-/// After the worker is initialized, you should use [CoreRuntime::tokio_handle] to run the worker's
-/// async functions.
-///
-/// Lang implementations may pass in a [ConfiguredClient] directly (or a
-/// [RetryClient] wrapping one, or a handful of other variants of the same idea). When they do so,
-/// this function will always overwrite the client retry configuration, force the client to use the
-/// namespace defined in the worker config, and set the client identity appropriately. IE: Use
-/// [ClientOptions::connect_no_namespace], not [ClientOptions::connect].
-pub fn init_worker<CT>(
-    runtime: &CoreRuntime,
-    worker_config: WorkerConfig,
-    client: CT,
-) -> Result<Worker, anyhow::Error>
-where
-    CT: Into<sealed::AnyClient>,
-{
-    let client = {
-        let ll = client.into().into_inner();
-        let mut client = Client::new(*ll, worker_config.namespace.clone());
-        client.set_worker_build_id(worker_config.worker_build_id.clone());
-        if let Some(ref id_override) = worker_config.client_identity_override {
-            client.options_mut().identity = id_override.clone();
-        }
-        RetryClient::new(client, RetryConfig::default())
-    };
-    if client.namespace() != worker_config.namespace {
-        panic!("Passed in client is not bound to the same namespace as the worker");
-    }
-    let client_ident = client.get_options().identity.clone();
-    let sticky_q = sticky_q_name_for_worker(&client_ident, &worker_config);
-    let client_bag = Arc::new(WorkerClientBag::new(
-        client,
-        worker_config.namespace.clone(),
-        client_ident,
-        worker_config.worker_build_id.clone(),
-        worker_config.use_worker_versioning,
-    ));
-
-    Ok(Worker::new(
-        worker_config,
-        sticky_q,
-        client_bag,
-        Some(&runtime.telemetry),
-    ))
-}
-
-/// Create a worker for replaying a specific history. It will auto-shutdown as soon as the history
-/// has finished being replayed.
-///
-/// You do not necessarily need a [CoreRuntime] for replay workers, but it's advisable to create
-/// one and use it to run the replay worker's async functions the same way you would for a normal
-/// worker.
-pub fn init_replay_worker<I>(
-    mut config: WorkerConfig,
-    histories: I,
-) -> Result<Worker, anyhow::Error>
-where
-    I: Stream<Item = HistoryForReplay> + Send + 'static,
-{
-    info!(
-        task_queue = config.task_queue.as_str(),
-        "Registering replay worker"
-    );
-    config.max_cached_workflows = 1;
-    config.max_concurrent_wft_polls = 1;
-    config.no_remote_activities = true;
-    let historator = Historator::new(histories);
-    let post_activate = historator.get_post_activate_hook();
-    let shutdown_tok = historator.get_shutdown_setter();
-    let client = mock_client_from_histories(historator);
-    let mut worker = Worker::new(config, None, Arc::new(client), None);
-    worker.set_post_activate_hook(post_activate);
-    shutdown_tok(worker.shutdown_token());
-    Ok(worker)
-}
-
-/// Creates a unique sticky queue name for a worker, iff the config allows for 1 or more cached
-/// workflows.
-pub(crate) fn sticky_q_name_for_worker(
-    process_identity: &str,
-    config: &WorkerConfig,
-) -> Option<String> {
-    if config.max_cached_workflows > 0 {
-        Some(format!(
-            "{}-{}-{}",
-            &process_identity,
-            &config.task_queue,
-            uuid::Uuid::new_v4().simple()
-        ))
-    } else {
-        None
-    }
-}
-
-mod sealed {
-    use super::*;
-
-    /// Allows passing different kinds of clients into things that want to be flexible. Motivating
-    /// use-case was worker initialization.
-    ///
-    /// Needs to exist in this crate to avoid blanket impl conflicts.
-    pub struct AnyClient(Box<ConfiguredClient<TemporalServiceClientWithMetrics>>);
-    impl AnyClient {
-        pub(crate) fn into_inner(self) -> Box<ConfiguredClient<TemporalServiceClientWithMetrics>> {
-            self.0
-        }
-    }
-
-    impl From<RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>> for AnyClient {
-        fn from(c: RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>) -> Self {
-            Self(Box::new(c.into_inner()))
-        }
-    }
-    impl From<RetryClient<Client>> for AnyClient {
-        fn from(c: RetryClient<Client>) -> Self {
-            Self(Box::new(c.into_inner().into_inner()))
-        }
-    }
-    impl From<Arc<RetryClient<Client>>> for AnyClient {
-        fn from(c: Arc<RetryClient<Client>>) -> Self {
-            Self(Box::new(c.get_client().inner().clone()))
-        }
-    }
-    impl From<ConfiguredClient<TemporalServiceClientWithMetrics>> for AnyClient {
-        fn from(c: ConfiguredClient<TemporalServiceClientWithMetrics>) -> Self {
-            Self(Box::new(c))
-        }
-    }
-}
-
-/// Holds shared state/components needed to back instances of workers and clients. More than one
-/// may be instantiated, but typically only one is needed. More than one runtime instance may be
-/// useful if multiple different telemetry settings are required.
-pub struct CoreRuntime {
-    telemetry: TelemetryInstance,
-    runtime: Option<tokio::runtime::Runtime>,
-    runtime_handle: tokio::runtime::Handle,
-}
-
-impl CoreRuntime {
-    /// Create a new core runtime with the provided telemetry options and tokio runtime builder.
-    /// Also initialize telemetry for the thread this is being called on.
-    ///
-    /// Note that this function will call the [tokio::runtime::Builder::enable_all] builder option
-    /// on the Tokio runtime builder, and will call [tokio::runtime::Builder::on_thread_start] to
-    /// ensure telemetry subscribers are set on every tokio thread.
-    ///
-    /// **Important**: You need to call this *before* calling any async functions on workers or
-    /// clients, otherwise the tracing subscribers will not be properly attached.
-    ///
-    /// # Panics
-    /// If a tokio runtime has already been initialized. To re-use an existing runtime, call
-    /// [CoreRuntime::new_assume_tokio].
-    pub fn new(
-        telemetry_options: TelemetryOptions,
-        mut tokio_builder: tokio::runtime::Builder,
-    ) -> Result<Self, anyhow::Error> {
-        let telemetry = telemetry_init(telemetry_options)?;
-        let subscriber = telemetry.trace_subscriber();
-        let runtime = tokio_builder
-            .enable_all()
-            .on_thread_start(move || {
-                set_trace_subscriber_for_current_thread(subscriber.clone());
-            })
-            .build()?;
-        let _rg = runtime.enter();
-        let mut me = Self::new_assume_tokio_initialized_telem(telemetry);
-        me.runtime = Some(runtime);
-        Ok(me)
-    }
-
-    /// Initialize telemetry for the thread this is being called on, assuming a tokio runtime is
-    /// already active and this call exists in its context. See [Self::new] for more.
-    ///
-    /// # Panics
-    /// If there is no currently active Tokio runtime
-    pub fn new_assume_tokio(telemetry_options: TelemetryOptions) -> Result<Self, anyhow::Error> {
-        let telemetry = telemetry_init(telemetry_options)?;
-        Ok(Self::new_assume_tokio_initialized_telem(telemetry))
-    }
-
-    /// Construct a runtime from an already-initialized telemetry instance, assuming a tokio runtime
-    /// is already active and this call exists in its context. See [Self::new] for more.
-    ///
-    /// # Panics
-    /// If there is no currently active Tokio runtime
-    pub fn new_assume_tokio_initialized_telem(telemetry: TelemetryInstance) -> Self {
-        let runtime_handle = tokio::runtime::Handle::current();
-        set_trace_subscriber_for_current_thread(telemetry.trace_subscriber());
-        Self {
-            telemetry,
-            runtime: None,
-            runtime_handle,
-        }
-    }
-
-    /// Get a handle to the tokio runtime used by this Core runtime.
-    pub fn tokio_handle(&self) -> tokio::runtime::Handle {
-        self.runtime_handle.clone()
-    }
-
-    /// Returns the metric meter used for recording metrics, if they were enabled.
-    pub fn metric_meter(&self) -> Option<TemporalMeter> {
-        self.telemetry.get_metric_meter()
-    }
-
-    /// Return the trace subscriber associated with the telemetry options/instance. Can be used
-    /// to manually set the default for a thread or globally using the `tracing` crate, or with
-    /// [set_trace_subscriber_for_current_thread]
-    pub fn trace_subscriber(&self) -> Arc<dyn tracing::Subscriber + Send + Sync> {
-        self.telemetry.trace_subscriber()
-    }
-
-    /// Return a reference to the owned [TelemetryInstance]
-    pub fn telemetry(&self) -> &TelemetryInstance {
-        &self.telemetry
-    }
-}
-
-impl Drop for CoreRuntime {
-    fn drop(&mut self) {
-        remove_trace_subscriber_for_current_thread();
-    }
-}

data/bridge/sdk-core/core/src/pollers/mod.rs

@@ -1,54 +0,0 @@
-mod poll_buffer;
-
-pub(crate) use poll_buffer::{
-    new_activity_task_buffer, new_workflow_task_buffer, WorkflowTaskPoller,
-};
-pub use temporal_client::{
-    Client, ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryClient, RetryConfig,
-    TlsConfig, WorkflowClientTrait,
-};
-use temporal_sdk_core_protos::temporal::api::workflowservice::v1::{
-    PollActivityTaskQueueResponse, PollWorkflowTaskQueueResponse,
-};
-
-#[cfg(test)]
-use futures::Future;
-
-pub type Result<T, E = tonic::Status> = std::result::Result<T, E>;
-
-/// A trait for things that poll the server. Hides complexity of concurrent polling or polling
-/// on sticky/nonsticky queues simultaneously.
-#[cfg_attr(test, mockall::automock)]
-#[cfg_attr(test, allow(unused))]
-#[async_trait::async_trait]
-pub trait Poller<PollResult>
-where
-    PollResult: Send + Sync + 'static,
-{
-    async fn poll(&self) -> Option<Result<PollResult>>;
-    fn notify_shutdown(&self);
-    async fn shutdown(self);
-    /// Need a separate shutdown to be able to consume boxes :(
-    async fn shutdown_box(self: Box<Self>);
-}
-pub type BoxedPoller<T> = Box<dyn Poller<T> + Send + Sync + 'static>;
-pub type BoxedWFPoller = BoxedPoller<PollWorkflowTaskQueueResponse>;
-pub type BoxedActPoller = BoxedPoller<PollActivityTaskQueueResponse>;
-
-#[cfg(test)]
-mockall::mock! {
-    pub ManualPoller<T: Send + Sync + 'static> {}
-    #[allow(unused)]
-    impl<T: Send + Sync + 'static> Poller<T> for ManualPoller<T> {
-        fn poll<'a, 'b>(&self)
-          -> impl Future<Output = Option<Result<T>>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-        fn notify_shutdown(&self);
-        fn shutdown<'a>(self)
-          -> impl Future<Output = ()> + Send + 'a
-            where Self: 'a;
-        fn shutdown_box<'a>(self: Box<Self>)
-          -> impl Future<Output = ()> + Send + 'a
-            where Self: 'a;
-    }
-}