temporalio 0.1.1 → 0.2.0

data/bridge/sdk-core/protos/testsrv_upstream/temporal/api/testservice/v1/service.proto

@@ -1,90 +0,0 @@
-// 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

@@ -1 +0,0 @@
-imports_granularity="Crate"

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

@@ -1,48 +0,0 @@
-[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"
-thiserror = "1.0"
-anyhow = "1.0"
-base64 = "0.21"
-crossbeam = "0.8"
-derive_more = "0.99"
-futures = "0.3"
-once_cell = "1.10"
-parking_lot = { version = "0.12", features = ["send_guard"] }
-prost-types = { version = "0.4", package = "prost-wkt-types" }
-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

@@ -1,23 +0,0 @@
-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

@@ -1,230 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,50 +0,0 @@
-//! 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(())
-    }
-}