temporalio 0.0.0 → 0.0.2

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 = "Temporalio::Api::TestService::V1";
+option csharp_namespace = "Temporalio.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"

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

@@ -0,0 +1,47 @@
+[package]
+name = "temporal-sdk"
+version = "0.1.0-alpha.1"
+edition = "2021"
+authors = ["Spencer Judge <spencer@temporal.io>"]
+license-file = "LICENSE.txt"
+description = "Temporal Rust SDK"
+homepage = "https://temporal.io/"
+repository = "https://github.com/temporalio/sdk-core"
+keywords = ["temporal", "workflow"]
+categories = ["development-tools"]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+async-trait = "0.1"
+anyhow = "1.0"
+base64 = "0.20"
+crossbeam = "0.8"
+derive_more = "0.99"
+futures = "0.3"
+once_cell = "1.10"
+parking_lot = { version = "0.12", features = ["send_guard"] }
+prost-types = "0.11"
+sha2 = "0.10"
+serde = "1.0"
+tokio = { version = "1.1", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs"] }
+tokio-util = { version = "0.7" }
+tokio-stream = "0.1"
+tonic = "0.8"
+tracing = "0.1"
+
+[dependencies.temporal-sdk-core]
+path = "../core"
+version = "0.1"
+
+[dependencies.temporal-sdk-core-protos]
+path = "../sdk-core-protos"
+version = "0.1"
+
+[dependencies.temporal-sdk-core-api]
+path = "../core-api"
+version = "0.1"
+
+[dependencies.temporal-client]
+path = "../client"
+version = "0.1"

data/bridge/sdk-core/sdk/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/sdk/src/activity_context.rs

@@ -0,0 +1,230 @@
+use crate::app_data::AppData;
+
+use prost_types::{Duration, Timestamp};
+use std::{
+    collections::HashMap,
+    sync::Arc,
+    time::{Duration as StdDuration, SystemTime},
+};
+use temporal_sdk_core_api::Worker;
+use temporal_sdk_core_protos::{
+    coresdk::{activity_task, ActivityHeartbeat},
+    temporal::api::common::v1::{Payload, RetryPolicy, WorkflowExecution},
+    utilities::TryIntoOrNone,
+};
+use tokio_util::sync::CancellationToken;
+
+/// Used within activities to get info, heartbeat management etc.
+#[derive(Clone)]
+pub struct ActContext {
+    worker: Arc<dyn Worker>,
+    app_data: Arc<AppData>,
+    cancellation_token: CancellationToken,
+    input: Vec<Payload>,
+    heartbeat_details: Vec<Payload>,
+    header_fields: HashMap<String, Payload>,
+    info: ActivityInfo,
+}
+
+#[derive(Clone)]
+pub struct ActivityInfo {
+    pub task_token: Vec<u8>,
+    pub workflow_type: String,
+    pub workflow_namespace: String,
+    pub workflow_execution: Option<WorkflowExecution>,
+    pub activity_id: String,
+    pub activity_type: String,
+    pub task_queue: String,
+    pub heartbeat_timeout: Option<StdDuration>,
+    /// Time activity was scheduled by a workflow
+    pub scheduled_time: Option<SystemTime>,
+    /// Time of activity start
+    pub started_time: Option<SystemTime>,
+    /// Time of activity timeout
+    pub deadline: Option<SystemTime>,
+    /// Attempt starts from 1, and increase by 1 for every retry, if retry policy is specified.
+    pub attempt: u32,
+    /// Time this attempt at the activity was scheduled
+    pub current_attempt_scheduled_time: Option<SystemTime>,
+    pub retry_policy: Option<RetryPolicy>,
+    pub is_local: bool,
+}
+
+impl ActContext {
+    /// Construct new Activity Context, returning the context and the first argument to the activity
+    /// (which may be a default [Payload]).
+    pub(crate) fn new(
+        worker: Arc<dyn Worker>,
+        app_data: Arc<AppData>,
+        cancellation_token: CancellationToken,
+        task_queue: String,
+        task_token: Vec<u8>,
+        task: activity_task::Start,
+    ) -> (Self, Payload) {
+        let activity_task::Start {
+            workflow_namespace,
+            workflow_type,
+            workflow_execution,
+            activity_id,
+            activity_type,
+            header_fields,
+            mut input,
+            heartbeat_details,
+            scheduled_time,
+            current_attempt_scheduled_time,
+            started_time,
+            attempt,
+            schedule_to_close_timeout,
+            start_to_close_timeout,
+            heartbeat_timeout,
+            retry_policy,
+            is_local,
+        } = task;
+        let deadline = calculate_deadline(
+            scheduled_time.as_ref(),
+            started_time.as_ref(),
+            start_to_close_timeout.as_ref(),
+            schedule_to_close_timeout.as_ref(),
+        );
+        let first_arg = input.pop().unwrap_or_default();
+
+        (
+            ActContext {
+                worker,
+                app_data,
+                cancellation_token,
+                input,
+                heartbeat_details,
+                header_fields,
+                info: ActivityInfo {
+                    task_token,
+                    task_queue,
+                    workflow_type,
+                    workflow_namespace,
+                    workflow_execution,
+                    activity_id,
+                    activity_type,
+                    heartbeat_timeout: heartbeat_timeout.try_into_or_none(),
+                    scheduled_time: scheduled_time.try_into_or_none(),
+                    started_time: started_time.try_into_or_none(),
+                    deadline,
+                    attempt,
+                    current_attempt_scheduled_time: current_attempt_scheduled_time
+                        .try_into_or_none(),
+                    retry_policy,
+                    is_local,
+                },
+            },
+            first_arg,
+        )
+    }
+
+    /// Returns a future the completes if and when the activity this was called inside has been
+    /// cancelled
+    pub async fn cancelled(&self) {
+        self.cancellation_token.clone().cancelled().await
+    }
+
+    /// Returns true if this activity has already been cancelled
+    pub fn is_cancelled(&self) -> bool {
+        self.cancellation_token.is_cancelled()
+    }
+
+    /// Retrieve extra parameters to the Activity. The first input is always popped and passed to
+    /// the Activity function for the currently executing activity. However, if more parameters are
+    /// passed, perhaps from another language's SDK, explicit access is available from extra_inputs
+    pub fn extra_inputs(&mut self) -> &mut [Payload] {
+        &mut self.input
+    }
+
+    /// Extract heartbeat details from last failed attempt. This is used in combination with retry policy.
+    pub fn get_heartbeat_details(&self) -> &[Payload] {
+        &self.heartbeat_details
+    }
+
+    /// RecordHeartbeat sends heartbeat for the currently executing activity
+    pub fn record_heartbeat(&self, details: Vec<Payload>) {
+        self.worker.record_activity_heartbeat(ActivityHeartbeat {
+            task_token: self.info.task_token.clone(),
+            details,
+        })
+    }
+
+    /// Get activity info of the executing activity
+    pub fn get_info(&self) -> &ActivityInfo {
+        &self.info
+    }
+
+    /// Get headers attached to this activity
+    pub fn headers(&self) -> &HashMap<String, Payload> {
+        &self.header_fields
+    }
+
+    /// Get custom Application Data
+    pub fn app_data<T: Send + Sync + 'static>(&self) -> Option<&T> {
+        self.app_data.get::<T>()
+    }
+}
+
+/// Deadline calculation.  This is a port of
+/// https://github.com/temporalio/sdk-go/blob/8651550973088f27f678118f997839fb1bb9e62f/internal/activity.go#L225
+fn calculate_deadline(
+    scheduled_time: Option<&Timestamp>,
+    started_time: Option<&Timestamp>,
+    start_to_close_timeout: Option<&Duration>,
+    schedule_to_close_timeout: Option<&Duration>,
+) -> Option<SystemTime> {
+    match (
+        scheduled_time,
+        started_time,
+        start_to_close_timeout,
+        schedule_to_close_timeout,
+    ) {
+        (
+            Some(scheduled),
+            Some(started),
+            Some(start_to_close_timeout),
+            Some(schedule_to_close_timeout),
+        ) => {
+            let scheduled: SystemTime = maybe_convert_timestamp(scheduled)?;
+            let started: SystemTime = maybe_convert_timestamp(started)?;
+            let start_to_close_timeout: StdDuration =
+                start_to_close_timeout.clone().try_into().ok()?;
+            let schedule_to_close_timeout: StdDuration =
+                schedule_to_close_timeout.clone().try_into().ok()?;
+
+            let start_to_close_deadline: SystemTime =
+                started.checked_add(start_to_close_timeout)?;
+            if schedule_to_close_timeout > StdDuration::ZERO {
+                let schedule_to_close_deadline =
+                    scheduled.checked_add(schedule_to_close_timeout)?;
+                // Minimum of the two deadlines.
+                if schedule_to_close_deadline < start_to_close_deadline {
+                    Some(schedule_to_close_deadline)
+                } else {
+                    Some(start_to_close_deadline)
+                }
+            } else {
+                Some(start_to_close_deadline)
+            }
+        }
+        _ => None,
+    }
+}
+
+/// Helper function lifted from prost_types::Timestamp implementation to prevent double cloning in
+/// error construction
+fn maybe_convert_timestamp(timestamp: &Timestamp) -> Option<SystemTime> {
+    let mut timestamp = timestamp.clone();
+    timestamp.normalize();
+
+    let system_time = if timestamp.seconds >= 0 {
+        std::time::UNIX_EPOCH.checked_add(StdDuration::from_secs(timestamp.seconds as u64))
+    } else {
+        std::time::UNIX_EPOCH.checked_sub(StdDuration::from_secs((-timestamp.seconds) as u64))
+    };
+
+    system_time.and_then(|system_time| {
+        system_time.checked_add(StdDuration::from_nanos(timestamp.nanos as u64))
+    })
+}

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

@@ -0,0 +1,37 @@
+use std::{
+    any::{Any, TypeId},
+    collections::HashMap,
+    fmt,
+};
+
+/// A Wrapper Type for workflow and activity app data
+#[derive(Default)]
+pub struct AppData {
+    map: HashMap<TypeId, Box<dyn Any + Send + Sync>>,
+}
+
+impl AppData {
+    /// Insert an item, overwritting duplicates
+    pub fn insert<T: Send + Sync + 'static>(&mut self, val: T) -> Option<T> {
+        self.map
+            .insert(TypeId::of::<T>(), Box::new(val))
+            .and_then(downcast_owned)
+    }
+
+    /// Get a reference to a type in the map
+    pub fn get<T: 'static>(&self) -> Option<&T> {
+        self.map
+            .get(&TypeId::of::<T>())
+            .and_then(|boxed| boxed.downcast_ref())
+    }
+}
+
+impl fmt::Debug for AppData {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("AppData").finish()
+    }
+}
+
+fn downcast_owned<T: Send + Sync + 'static>(boxed: Box<dyn Any + Send + Sync>) -> Option<T> {
+    boxed.downcast().ok().map(|boxed| *boxed)
+}

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

@@ -0,0 +1,50 @@
+//! User-definable interceptors are defined in this module
+
+use crate::Worker;
+use anyhow::bail;
+use temporal_sdk_core_protos::coresdk::{
+    workflow_activation::{remove_from_cache::EvictionReason, WorkflowActivation},
+    workflow_completion::WorkflowActivationCompletion,
+};
+
+/// Implementors can intercept certain actions that happen within the Worker.
+///
+/// Advanced usage only.
+#[async_trait::async_trait(?Send)]
+pub trait WorkerInterceptor {
+    /// Called every time a workflow activation completes (just before sending the completion to
+    /// core).
+    async fn on_workflow_activation_completion(&self, _completion: &WorkflowActivationCompletion) {}
+    /// Called after the worker has initiated shutdown and the workflow/activity polling loops
+    /// have exited, but just before waiting for the inner core worker shutdown
+    fn on_shutdown(&self, _sdk_worker: &Worker) {}
+    /// Called every time a workflow is about to be activated
+    async fn on_workflow_activation(
+        &self,
+        _activation: &WorkflowActivation,
+    ) -> Result<(), anyhow::Error> {
+        Ok(())
+    }
+}
+
+/// An interceptor which causes the worker's run function to exit early if nondeterminism errors are
+/// encountered
+pub struct FailOnNondeterminismInterceptor {}
+#[async_trait::async_trait(?Send)]
+impl WorkerInterceptor for FailOnNondeterminismInterceptor {
+    async fn on_workflow_activation(
+        &self,
+        activation: &WorkflowActivation,
+    ) -> Result<(), anyhow::Error> {
+        if matches!(
+            activation.eviction_reason(),
+            Some(EvictionReason::Nondeterminism)
+        ) {
+            bail!(
+                "Workflow is being evicted because of nondeterminism! {}",
+                activation
+            );
+        }
+        Ok(())
+    }
+}