temporalio 0.0.0 → 0.0.1

data/bridge/sdk-core/client/src/workflow_handle/mod.rs

@@ -0,0 +1,185 @@
+use crate::{InterceptedMetricsSvc, RawClientLike};
+use anyhow::{anyhow, bail};
+use std::marker::PhantomData;
+use temporal_sdk_core_protos::{
+    coresdk::FromPayloadsExt,
+    temporal::api::{
+        common::v1::{Payload, WorkflowExecution},
+        enums::v1::HistoryEventFilterType,
+        failure::v1::Failure,
+        history::v1::history_event::Attributes,
+        workflowservice::v1::GetWorkflowExecutionHistoryRequest,
+    },
+};
+
+/// Enumerates terminal states for a particular workflow execution
+// TODO: Add non-proto failure types, flesh out details, etc.
+#[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum WorkflowExecutionResult<T> {
+    /// The workflow finished successfully
+    Succeeded(T),
+    /// The workflow finished in failure
+    Failed(Failure),
+    /// The workflow was cancelled
+    Cancelled(Vec<Payload>),
+    /// The workflow was terminated
+    Terminated(Vec<Payload>),
+    /// The workflow timed out
+    TimedOut,
+    /// The workflow continued as new
+    ContinuedAsNew,
+}
+
+/// Options for fetching workflow results
+#[derive(Debug, Clone, Copy)]
+pub struct GetWorkflowResultOpts {
+    /// If true (the default), follows to the next workflow run in the execution chain while
+    /// retrieving results.
+    pub follow_runs: bool,
+}
+impl Default for GetWorkflowResultOpts {
+    fn default() -> Self {
+        Self { follow_runs: true }
+    }
+}
+
+/// A workflow handle which can refer to a specific workflow run, or a chain of workflow runs with
+/// the same workflow id.
+pub struct WorkflowHandle<ClientT, ResultT> {
+    client: ClientT,
+    info: WorkflowExecutionInfo,
+
+    _res_type: PhantomData<ResultT>,
+}
+
+/// Holds needed information to refer to a specific workflow run, or workflow execution chain
+pub struct WorkflowExecutionInfo {
+    /// Namespace the workflow lives in
+    pub namespace: String,
+    /// The workflow's id
+    pub workflow_id: String,
+    /// If set, target this specific run of the workflow
+    pub run_id: Option<String>,
+}
+
+impl WorkflowExecutionInfo {
+    /// Bind the workflow info to a specific client, turning it into a workflow handle
+    pub fn bind_untyped<CT>(self, client: CT) -> UntypedWorkflowHandle<CT>
+    where
+        CT: RawClientLike<SvcType = InterceptedMetricsSvc> + Clone,
+    {
+        UntypedWorkflowHandle::new(client, self)
+    }
+}
+
+/// A workflow handle to a workflow with unknown types. Uses raw payloads.
+pub type UntypedWorkflowHandle<CT> = WorkflowHandle<CT, Vec<Payload>>;
+
+impl<CT, RT> WorkflowHandle<CT, RT>
+where
+    CT: RawClientLike<SvcType = InterceptedMetricsSvc> + Clone,
+    // TODO: Make more generic, capable of (de)serialization w/ serde
+    RT: FromPayloadsExt,
+{
+    pub(crate) fn new(client: CT, info: WorkflowExecutionInfo) -> Self {
+        Self {
+            client,
+            info,
+            _res_type: PhantomData::<RT>,
+        }
+    }
+
+    pub async fn get_workflow_result(
+        &self,
+        opts: GetWorkflowResultOpts,
+    ) -> Result<WorkflowExecutionResult<RT>, anyhow::Error> {
+        let mut next_page_tok = vec![];
+        let mut run_id = self.info.run_id.clone().unwrap_or_default();
+        loop {
+            let server_res = self
+                .client
+                .clone()
+                .workflow_client()
+                .get_workflow_execution_history(GetWorkflowExecutionHistoryRequest {
+                    namespace: self.info.namespace.to_string(),
+                    execution: Some(WorkflowExecution {
+                        workflow_id: self.info.workflow_id.clone(),
+                        run_id: run_id.clone(),
+                    }),
+                    skip_archival: true,
+                    wait_new_event: true,
+                    history_event_filter_type: HistoryEventFilterType::CloseEvent as i32,
+                    next_page_token: next_page_tok.clone(),
+                    ..Default::default()
+                })
+                .await?
+                .into_inner();
+
+            let mut history = server_res
+                .history
+                .ok_or_else(|| anyhow!("Server returned an empty history!"))?;
+
+            if history.events.is_empty() {
+                next_page_tok = server_res.next_page_token;
+                continue;
+            }
+            // If page token was previously set, clear it.
+            next_page_tok = vec![];
+
+            let event_attrs = history.events.pop().and_then(|ev| ev.attributes);
+
+            macro_rules! follow {
+                ($attrs:ident) => {
+                    if opts.follow_runs && $attrs.new_execution_run_id != "" {
+                        run_id = $attrs.new_execution_run_id;
+                        continue;
+                    }
+                };
+            }
+
+            break match event_attrs {
+                Some(Attributes::WorkflowExecutionCompletedEventAttributes(attrs)) => {
+                    follow!(attrs);
+                    Ok(WorkflowExecutionResult::Succeeded(RT::from_payloads(
+                        attrs.result,
+                    )))
+                }
+                Some(Attributes::WorkflowExecutionFailedEventAttributes(attrs)) => {
+                    follow!(attrs);
+                    Ok(WorkflowExecutionResult::Failed(
+                        attrs.failure.unwrap_or_default(),
+                    ))
+                }
+                Some(Attributes::WorkflowExecutionCanceledEventAttributes(attrs)) => Ok(
+                    WorkflowExecutionResult::Cancelled(Vec::from_payloads(attrs.details)),
+                ),
+                Some(Attributes::WorkflowExecutionTimedOutEventAttributes(attrs)) => {
+                    follow!(attrs);
+                    Ok(WorkflowExecutionResult::TimedOut)
+                }
+                Some(Attributes::WorkflowExecutionTerminatedEventAttributes(attrs)) => Ok(
+                    WorkflowExecutionResult::Terminated(Vec::from_payloads(attrs.details)),
+                ),
+                Some(Attributes::WorkflowExecutionContinuedAsNewEventAttributes(attrs)) => {
+                    if opts.follow_runs {
+                        if !attrs.new_execution_run_id.is_empty() {
+                            run_id = attrs.new_execution_run_id;
+                            continue;
+                        } else {
+                            bail!("New execution run id was empty in continue as new event!");
+                        }
+                    } else {
+                        Ok(WorkflowExecutionResult::ContinuedAsNew)
+                    }
+                }
+                o => Err(anyhow!(
+                    "Server returned an event that didn't match the CloseEvent filter. \
+                     This is either a server bug or a new event the SDK does not understand. \
+                     Event details: {:?}",
+                    o
+                )),
+            };
+        }
+    }
+}

data/bridge/sdk-core/core/Cargo.toml

@@ -0,0 +1,116 @@
+[package]
+name = "temporal-sdk-core"
+version = "0.1.0"
+authors = ["Spencer Judge <spencer@temporal.io>", "Vitaly Arbuzov <vitaly@temporal.io>"]
+edition = "2021"
+license-file = "LICENSE.txt"
+description = "Library for building new Temporal SDKs"
+homepage = "https://temporal.io/"
+repository = "https://github.com/temporalio/sdk-core"
+keywords = ["temporal", "workflow"]
+categories = ["development-tools"]
+
+[lib]
+
+[dependencies]
+anyhow = "1.0"
+arc-swap = "1.3"
+async-channel = "1.6"
+async-trait = "0.1"
+base64 = "0.13"
+crossbeam = "0.8"
+dashmap = "5.0"
+derive_builder = "0.11"
+derive_more = "0.99"
+enum_dispatch = "0.3"
+flate2 = "1.0"
+futures = "0.3"
+futures-util = "0.3"
+governor = "0.5"
+http = "0.2"
+hyper = "0.14"
+itertools = "0.10"
+lazy_static = "1.4"
+log = "0.4"
+lru = "0.8"
+mockall = "0.11"
+nix = "0.25"
+once_cell = "1.5"
+opentelemetry = { version = "0.18", features = ["rt-tokio"] }
+opentelemetry-otlp = { version = "0.11", features = ["tokio", "metrics"] }
+opentelemetry-prometheus = "0.11"
+parking_lot = { version = "0.12", features = ["send_guard"] }
+prometheus = "0.13"
+prost = "0.11"
+prost-types = "0.11"
+rand = "0.8.3"
+reqwest = { version = "0.11", features = ["json", "stream", "rustls-tls", "tokio-rustls"], default-features = false }
+ringbuf = "0.2"
+serde = "1.0"
+serde_json = "1.0"
+siphasher = "0.3"
+slotmap = "1.0"
+tar = "0.4"
+thiserror = "1.0"
+tokio = { version = "1.1", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs", "process"] }
+tokio-util = { version = "0.7", features = ["io", "io-util"] }
+tokio-stream = "0.1"
+tonic = { version = "0.8", features = ["tls", "tls-roots"] }
+tracing = { version = "0.1", features = ["log-always"] }
+tracing-futures = "0.2"
+tracing-opentelemetry = "0.18"
+tracing-subscriber = { version = "0.3", features = ["parking_lot", "env-filter"] }
+url = "2.2"
+uuid = { version = "1.1", features = ["v4"] }
+zip = "0.6"
+
+# 1st party local deps
+[dependencies.temporal-sdk-core-api]
+path = "../core-api"
+version = "0.1"
+
+[dependencies.temporal-sdk-core-protos]
+path = "../sdk-core-protos"
+version = "0.1"
+features = ["history_builders"]
+
+[dependencies.temporal-client]
+path = "../client"
+version = "0.1"
+
+[dependencies.rustfsm]
+path = "../fsm"
+version = "0.1"
+
+[dev-dependencies]
+assert_matches = "1.4"
+bimap = "0.6.1"
+criterion = "0.4"
+rstest = "0.15"
+temporal-sdk-core-test-utils = { path = "../test-utils" }
+temporal-sdk = { path = "../sdk" }
+
+[build-dependencies]
+tonic-build = "0.8"
+
+[[test]]
+name = "integ_tests"
+path = "../tests/main.rs"
+# Prevents autodiscovery, and hence these getting run with `cargo test`. Run with
+# `cargo test --test integ_tests`
+test = false
+
+[[test]]
+name = "load_tests"
+path = "../tests/load_tests.rs"
+test = false
+
+[[bench]]
+name = "workflow_replay"
+harness = false
+
+# This is maybe a bit hacky, but we call the runner an "example" because that gets it compiling with
+# the dev-dependencies, which we want.
+[[example]]
+name = "integ_runner"
+path = "../tests/runner.rs"

data/bridge/sdk-core/core/LICENSE.txt

@@ -0,0 +1,23 @@
+Temporal Core SDK
+
+The MIT License
+
+Copyright (c) 2021 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.

data/bridge/sdk-core/core/benches/workflow_replay.rs

@@ -0,0 +1,73 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use futures::StreamExt;
+use std::time::Duration;
+use temporal_sdk::{WfContext, Worker, WorkflowFunction};
+use temporal_sdk_core::{telemetry_init, TelemetryOptionsBuilder};
+use temporal_sdk_core_protos::DEFAULT_WORKFLOW_TYPE;
+use temporal_sdk_core_test_utils::{canned_histories, init_core_replay_preloaded};
+
+pub fn criterion_benchmark(c: &mut Criterion) {
+    let tokio_runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_time()
+        .build()
+        .unwrap();
+    telemetry_init(&TelemetryOptionsBuilder::default().build().unwrap()).unwrap();
+    let _g = tokio_runtime.enter();
+
+    let num_timers = 10;
+    let t = canned_histories::long_sequential_timers(num_timers as usize);
+    let hist = t.get_full_history_info().unwrap().into();
+
+    c.bench_function("Small history replay", |b| {
+        b.iter(|| {
+            tokio_runtime.block_on(async {
+                let func = timers_wf(num_timers);
+                let (worker, _) = init_core_replay_preloaded("replay_bench", &hist);
+                let mut worker = Worker::new_from_core(worker, "replay_bench".to_string());
+                worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+                worker.run().await.unwrap();
+            })
+        })
+    });
+
+    let num_tasks = 50;
+    let t = canned_histories::lots_of_big_signals(num_tasks);
+    let hist = t.get_full_history_info().unwrap().into();
+
+    c.bench_function("Large payloads history replay", |b| {
+        b.iter(|| {
+            tokio_runtime.block_on(async {
+                let func = big_signals_wf(num_tasks);
+                let (worker, _) = init_core_replay_preloaded("large_hist_bench", &hist);
+                let mut worker = Worker::new_from_core(worker, "large_hist_bench".to_string());
+                worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+                worker.run().await.unwrap();
+            })
+        })
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
+
+fn timers_wf(num_timers: u32) -> WorkflowFunction {
+    WorkflowFunction::new(move |ctx: WfContext| async move {
+        for _ in 1..=num_timers {
+            ctx.timer(Duration::from_secs(1)).await;
+        }
+        Ok(().into())
+    })
+}
+
+fn big_signals_wf(num_tasks: usize) -> WorkflowFunction {
+    WorkflowFunction::new(move |ctx: WfContext| async move {
+        let mut sigs = ctx.make_signal_channel("bigsig");
+        for _ in 1..=num_tasks {
+            for _ in 1..=5 {
+                let _ = sigs.next().await.unwrap();
+            }
+        }
+
+        Ok(().into())
+    })
+}

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

@@ -0,0 +1,166 @@
+//! This module contains very generic helpers that can be used codebase-wide
+
+use crate::MetricsContext;
+use futures::{stream, Stream, StreamExt};
+use std::{
+    fmt::{Debug, Formatter},
+    future::Future,
+    sync::Arc,
+};
+use tokio::sync::{AcquireError, Notify, OwnedSemaphorePermit, Semaphore, TryAcquireError};
+
+/// Wraps a [Semaphore] with a function call that is fed the available permits any time a permit is
+/// acquired or restored through the provided methods
+#[derive(Clone)]
+pub(crate) struct MeteredSemaphore {
+    sem: Arc<Semaphore>,
+    metrics_ctx: MetricsContext,
+    record_fn: fn(&MetricsContext, usize),
+}
+
+impl MeteredSemaphore {
+    pub fn new(
+        inital_permits: usize,
+        metrics_ctx: MetricsContext,
+        record_fn: fn(&MetricsContext, usize),
+    ) -> Self {
+        Self {
+            sem: Arc::new(Semaphore::new(inital_permits)),
+            metrics_ctx,
+            record_fn,
+        }
+    }
+
+    pub fn available_permits(&self) -> usize {
+        self.sem.available_permits()
+    }
+
+    pub async fn acquire_owned(&self) -> Result<OwnedMeteredSemPermit, AcquireError> {
+        let res = self.sem.clone().acquire_owned().await?;
+        self.record();
+        Ok(OwnedMeteredSemPermit {
+            inner: res,
+            record_fn: self.record_drop_owned(),
+        })
+    }
+
+    pub fn try_acquire_owned(&self) -> Result<OwnedMeteredSemPermit, TryAcquireError> {
+        let res = self.sem.clone().try_acquire_owned()?;
+        self.record();
+        Ok(OwnedMeteredSemPermit {
+            inner: res,
+            record_fn: self.record_drop_owned(),
+        })
+    }
+
+    fn record(&self) {
+        (self.record_fn)(&self.metrics_ctx, self.sem.available_permits());
+    }
+
+    fn record_drop_owned(&self) -> Box<dyn Fn() + Send + Sync> {
+        let rcf = self.record_fn;
+        let mets = self.metrics_ctx.clone();
+        let sem = self.sem.clone();
+        Box::new(move || rcf(&mets, sem.available_permits() + 1))
+    }
+}
+
+/// Wraps an [OwnedSemaphorePermit] to update metrics when it's dropped
+pub(crate) struct OwnedMeteredSemPermit {
+    inner: OwnedSemaphorePermit,
+    record_fn: Box<dyn Fn() + Send + Sync>,
+}
+impl Drop for OwnedMeteredSemPermit {
+    fn drop(&mut self) {
+        (self.record_fn)()
+    }
+}
+impl Debug for OwnedMeteredSemPermit {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+
+/// From the input stream, create a new stream which only pulls from the input stream when allowed.
+/// When allowed is determined by the passed in `proceeder` which must return a future every time
+/// it's called. The input stream is only pulled from when that future resolves.
+pub(crate) fn stream_when_allowed<S, F, FF>(
+    input: S,
+    proceeder: FF,
+) -> impl Stream<Item = (S::Item, F::Output)>
+where
+    S: Stream + Send + 'static,
+    F: Future,
+    FF: FnMut() -> F,
+{
+    let acceptable_notify = Arc::new(Notify::new());
+    acceptable_notify.notify_one();
+    let stream = stream::unfold(
+        (proceeder, input.boxed()),
+        |(mut proceeder, mut input)| async {
+            let v = proceeder().await;
+            input.next().await.map(|i| ((i, v), (proceeder, input)))
+        },
+    );
+    stream
+}
+
+macro_rules! dbg_panic {
+  ($($arg:tt)*) => {
+      error!($($arg)*);
+      debug_assert!(true, $($arg)*);
+  };
+}
+pub(crate) use dbg_panic;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use futures::pin_mut;
+    use std::{cell::RefCell, task::Poll};
+    use tokio::sync::mpsc::unbounded_channel;
+
+    // This is fine. Test only / guaranteed to happen serially.
+    #[allow(clippy::await_holding_refcell_ref)]
+    #[test]
+    fn stream_when_allowed_works() {
+        let inputs = stream::iter([1, 2, 3]);
+        let (allow_tx, allow_rx) = unbounded_channel();
+        let allow_rx = RefCell::new(allow_rx);
+        let when_allowed = stream_when_allowed(inputs, || async {
+            allow_rx.borrow_mut().recv().await.unwrap()
+        });
+
+        let waker = futures::task::noop_waker_ref();
+        let mut cx = std::task::Context::from_waker(waker);
+        pin_mut!(when_allowed);
+
+        allow_tx.send(()).unwrap();
+        assert_eq!(
+            when_allowed.poll_next_unpin(&mut cx),
+            Poll::Ready(Some((1, ())))
+        );
+        // Now, it won't be ready
+        for _ in 1..10 {
+            assert_eq!(when_allowed.poll_next_unpin(&mut cx), Poll::Pending);
+        }
+        allow_tx.send(()).unwrap();
+        assert_eq!(
+            when_allowed.poll_next_unpin(&mut cx),
+            Poll::Ready(Some((2, ())))
+        );
+        for _ in 1..10 {
+            assert_eq!(when_allowed.poll_next_unpin(&mut cx), Poll::Pending);
+        }
+        allow_tx.send(()).unwrap();
+        assert_eq!(
+            when_allowed.poll_next_unpin(&mut cx),
+            Poll::Ready(Some((3, ())))
+        );
+        for _ in 1..10 {
+            assert_eq!(when_allowed.poll_next_unpin(&mut cx), Poll::Pending);
+        }
+        allow_tx.send(()).unwrap();
+        assert_eq!(when_allowed.poll_next_unpin(&mut cx), Poll::Ready(None));
+    }
+}