temporalio 0.0.0 → 0.0.1

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/dynamic_dest_pass.rs

@@ -0,0 +1,41 @@
+#![allow(dead_code)]
+
+extern crate rustfsm_trait as rustfsm;
+
+use rustfsm_procmacro::fsm;
+use rustfsm_trait::TransitionResult;
+use std::convert::Infallible;
+
+fsm! {
+    name SimpleMachine; command SimpleMachineCommand; error Infallible;
+
+    One --(A(String), foo)--> Two;
+    One --(A(String), foo)--> Three;
+
+    Two --(B(String), bar)--> One;
+    Two --(B(String), bar)--> Two;
+    Two --(B(String), bar)--> Three;
+}
+
+#[derive(Default, Clone)]
+pub struct One {}
+impl One {
+    fn foo(self, _: String) -> SimpleMachineTransition<TwoOrThree> {
+        TransitionResult::ok(vec![], Two {}.into())
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct Two {}
+impl Two {
+    fn bar(self, _: String) -> SimpleMachineTransition<OneOrTwoOrThree> {
+        TransitionResult::ok(vec![], Three {}.into())
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct Three {}
+
+pub enum SimpleMachineCommand {}
+
+fn main() {}

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/forgot_name_fail.rs

@@ -0,0 +1,14 @@
+extern crate rustfsm_trait as rustfsm;
+
+use rustfsm_procmacro::fsm;
+
+fsm! {
+    One --(A)--> Two
+}
+
+#[derive(Default, Clone)]
+pub struct One {}
+#[derive(Default, Clone)]
+pub struct Two {}
+
+fn main() {}

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/forgot_name_fail.stderr

@@ -0,0 +1,11 @@
+error: expected `name`
+ --> $DIR/forgot_name_fail.rs:6:5
+  |
+6 |     One --(A)--> Two
+  |     ^^^
+
+error: The fsm definition should begin with `name MachineName; command CommandType; error ErrorType;` optionally followed by `shared_state SharedStateType;`
+ --> $DIR/forgot_name_fail.rs:6:5
+  |
+6 |     One --(A)--> Two
+  |     ^^^

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/handler_arg_pass.rs

@@ -0,0 +1,32 @@
+extern crate rustfsm_trait as rustfsm;
+
+use rustfsm_procmacro::fsm;
+use rustfsm_trait::TransitionResult;
+use std::convert::Infallible;
+
+fsm! {
+    name Simple; command SimpleCommand; error Infallible;
+
+    One --(A(String), on_a)--> Two
+}
+
+#[derive(Default, Clone)]
+pub struct One {}
+impl One {
+    fn on_a(self, _: String) -> SimpleTransition<Two> {
+        SimpleTransition::ok(vec![], Two {})
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct Two {}
+
+pub enum SimpleCommand {}
+
+fn main() {
+    // state enum exists with both states
+    let _ = SimpleState::One(One {});
+    let _ = SimpleState::Two(Two {});
+    // Avoid dead code warning
+    let _ = SimpleEvents::A("yo".to_owned());
+}

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/handler_pass.rs

@@ -0,0 +1,31 @@
+extern crate rustfsm_trait as rustfsm;
+
+use rustfsm_procmacro::fsm;
+use rustfsm_trait::TransitionResult;
+use std::convert::Infallible;
+
+fsm! {
+    name Simple; command SimpleCommand; error Infallible;
+
+    One --(A, on_a)--> Two
+}
+
+#[derive(Default, Clone)]
+pub struct One {}
+impl One {
+    fn on_a(self) -> SimpleTransition<Two> {
+        SimpleTransition::ok(vec![], Two {})
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct Two {}
+
+pub enum SimpleCommand {}
+
+fn main() {
+    // state enum exists with both states
+    let _ = SimpleState::One(One {});
+    let _ = SimpleState::Two(Two {});
+    let _ = SimpleEvents::A;
+}

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/medium_complex_pass.rs

@@ -0,0 +1,46 @@
+#![allow(dead_code)]
+
+extern crate rustfsm_trait as rustfsm;
+
+use rustfsm_procmacro::fsm;
+use rustfsm_trait::TransitionResult;
+use std::convert::Infallible;
+
+fsm! {
+    name SimpleMachine; command SimpleMachineCommand; error Infallible;
+
+    One --(A(String), foo)--> Two;
+    One --(B)--> Two;
+    Two --(B)--> One;
+    Two --(C, baz)--> One
+}
+
+#[derive(Default, Clone)]
+pub struct One {}
+impl One {
+    fn foo(self, _: String) -> SimpleMachineTransition<Two> {
+        TransitionResult::default()
+    }
+}
+impl From<Two> for One {
+    fn from(_: Two) -> Self {
+        One {}
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct Two {}
+impl Two {
+    fn baz(self) -> SimpleMachineTransition<One> {
+        TransitionResult::default()
+    }
+}
+impl From<One> for Two {
+    fn from(_: One) -> Self {
+        Two {}
+    }
+}
+
+pub enum SimpleMachineCommand {}
+
+fn main() {}

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/no_handle_conversions_require_into_fail.rs

@@ -0,0 +1,29 @@
+extern crate rustfsm_trait as rustfsm;
+
+use rustfsm_procmacro::fsm;
+use rustfsm_trait::TransitionResult;
+use std::convert::Infallible;
+
+fsm! {
+    name SimpleMachine; command SimpleMachineCommand; error Infallible;
+
+    One --(A)--> Two;
+    Two --(B)--> One;
+}
+
+#[derive(Default, Clone)]
+pub struct One {}
+
+#[derive(Default, Clone)]
+pub struct Two {}
+// We implement one of them because trait bound satisfaction error output is not deterministically
+// ordered
+impl From<One> for Two {
+    fn from(_: One) -> Self {
+        Two {}
+    }
+}
+
+enum SimpleMachineCommand {}
+
+fn main() {}

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/no_handle_conversions_require_into_fail.stderr

@@ -0,0 +1,12 @@
+error[E0277]: the trait bound `One: From<Two>` is not satisfied
+   --> tests/trybuild/no_handle_conversions_require_into_fail.rs:11:18
+    |
+11  |     Two --(B)--> One;
+    |                  ^^^ the trait `From<Two>` is not implemented for `One`
+    |
+    = note: required because of the requirements on the impl of `Into<One>` for `Two`
+note: required by a bound in `TransitionResult::<Sm, Ds>::from`
+   --> $WORKSPACE/fsm/rustfsm_trait/src/lib.rs
+    |
+    |         CurrentState: Into<Ds>,
+    |                       ^^^^^^^^ required by this bound in `TransitionResult::<Sm, Ds>::from`

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/simple_pass.rs

@@ -0,0 +1,32 @@
+extern crate rustfsm_trait as rustfsm;
+
+use rustfsm_procmacro::fsm;
+use rustfsm_trait::TransitionResult;
+use std::convert::Infallible;
+
+fsm! {
+    name SimpleMachine; command SimpleMachineCommand; error Infallible;
+
+    One --(A)--> Two
+}
+
+#[derive(Default, Clone)]
+pub struct One {}
+
+#[derive(Default, Clone)]
+pub struct Two {}
+impl From<One> for Two {
+    fn from(_: One) -> Self {
+        Two {}
+    }
+}
+
+pub enum SimpleMachineCommand {}
+
+fn main() {
+    // state enum exists with both states
+    let _ = SimpleMachineState::One(One {});
+    let _ = SimpleMachineState::Two(Two {});
+    // Event enum exists
+    let _ = SimpleMachineEvents::A;
+}

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/struct_event_variant_fail.rs

@@ -0,0 +1,18 @@
+extern crate rustfsm_trait as rustfsm;
+
+use rustfsm_procmacro::fsm;
+
+fsm! {
+    name Simple; command SimpleCommand; error Infallible;
+
+    One --(A{foo: String}, on_a)--> Two
+}
+
+#[derive(Default, Clone)]
+pub struct One {}
+#[derive(Default, Clone)]
+pub struct Two {}
+
+pub enum SimpleCommand {}
+
+fn main() {}

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/struct_event_variant_fail.stderr

@@ -0,0 +1,5 @@
+error: Struct variants are not supported for events
+ --> $DIR/struct_event_variant_fail.rs:8:12
+  |
+8 |     One --(A{foo: String}, on_a)--> Two
+  |            ^

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/tuple_more_item_event_variant_fail.rs

@@ -0,0 +1,11 @@
+extern crate rustfsm_trait as rustfsm;
+
+use rustfsm_procmacro::fsm;
+
+fsm! {
+    name Simple; command SimpleCmd; error Infallible;
+
+    One --(A(Foo, Bar), on_a)--> Two
+}
+
+fn main() {}

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/tuple_more_item_event_variant_fail.stderr

@@ -0,0 +1,5 @@
+error: Only tuple variants with exactly one item are supported for events
+ --> $DIR/tuple_more_item_event_variant_fail.rs:8:12
+  |
+8 |     One --(A(Foo, Bar), on_a)--> Two
+  |            ^

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/tuple_zero_item_event_variant_fail.rs

@@ -0,0 +1,11 @@
+extern crate rustfsm_trait as rustfsm;
+
+use rustfsm_procmacro::fsm;
+
+fsm! {
+    name Simple; command SimpleCmd; error Infallible;
+
+    One --(A(), on_a)--> Two
+}
+
+fn main() {}

data/bridge/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/tuple_zero_item_event_variant_fail.stderr

@@ -0,0 +1,5 @@
+error: Only tuple variants with exactly one item are supported for events
+ --> $DIR/tuple_zero_item_event_variant_fail.rs:8:12
+  |
+8 |     One --(A(), on_a)--> Two
+  |            ^

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

@@ -0,0 +1,14 @@
+[package]
+name = "rustfsm_trait"
+version = "0.1.0"
+authors = ["Spencer Judge <spencer@temporal.io>"]
+edition = "2021"
+license-file = "LICENSE.txt"
+description = "Trait sub-crate of the `rustfsm` crate"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+
+[package.metadata.workspaces]
+independent = true

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

@@ -0,0 +1,249 @@
+use std::{
+    error::Error,
+    fmt::{Debug, Display, Formatter},
+};
+
+/// This trait defines a state machine (more formally, a [finite state
+/// transducer](https://en.wikipedia.org/wiki/Finite-state_transducer)) which accepts events (the
+/// input alphabet), uses them to mutate itself, and (may) output some commands (the output
+/// alphabet) as a result.
+pub trait StateMachine: Sized {
+    /// The error type produced by this state machine when handling events
+    type Error: Error;
+    /// The type used to represent different machine states. Should be an enum.
+    type State;
+    /// The type used to represent state that common among all states. Should be a struct.
+    type SharedState;
+    /// The type used to represent events the machine handles. Should be an enum.
+    type Event;
+    /// The type used to represent commands the machine issues upon transitions.
+    type Command;
+
+    /// Handle an incoming event, returning a transition result which represents updates to apply
+    /// to the state machine.
+    fn on_event(self, event: Self::Event) -> TransitionResult<Self, Self::State>;
+
+    /// Handle an incoming event and mutate the state machine to update to the new state and apply
+    /// any changes to shared state.
+    ///
+    /// Returns the commands issued by the transition on success, otherwise a [MachineError]
+    fn on_event_mut(
+        &mut self,
+        event: Self::Event,
+    ) -> Result<Vec<Self::Command>, MachineError<Self::Error>>
+    where
+        Self: Clone,
+    {
+        // NOTE: This clone is actually nice in some sense, giving us a kind of transactionality.
+        //   However if there are really big things in state it could be an issue.
+        let res = self.clone().on_event(event);
+        match res {
+            TransitionResult::Ok {
+                commands,
+                new_state,
+                shared_state,
+            } => {
+                *self = Self::from_parts(shared_state, new_state);
+                Ok(commands)
+            }
+            TransitionResult::OkNoShare {
+                commands,
+                new_state,
+            } => {
+                self.set_state(new_state);
+                Ok(commands)
+            }
+            TransitionResult::InvalidTransition => Err(MachineError::InvalidTransition),
+            TransitionResult::Err(e) => Err(MachineError::Underlying(e)),
+        }
+    }
+
+    fn name(&self) -> &str;
+
+    /// Returns the current state of the machine
+    fn state(&self) -> &Self::State;
+    fn set_state(&mut self, new_state: Self::State);
+
+    /// Returns the current shared state of the machine
+    fn shared_state(&self) -> &Self::SharedState;
+
+    /// Returns true if the machine's current state is a final one
+    fn has_reached_final_state(&self) -> bool;
+
+    /// Given the shared data and new state, create a new instance.
+    fn from_parts(shared: Self::SharedState, state: Self::State) -> Self;
+
+    /// Return a PlantUML definition of the fsm that can be used to visualize it
+    fn visualizer() -> &'static str;
+}
+
+/// The error returned by [StateMachine]s when handling events
+#[derive(Debug)]
+pub enum MachineError<E: Error> {
+    /// An undefined transition was attempted
+    InvalidTransition,
+    /// Some error occurred while processing the transition
+    Underlying(E),
+}
+
+impl<E: Error> From<E> for MachineError<E> {
+    fn from(e: E) -> Self {
+        Self::Underlying(e)
+    }
+}
+
+impl<E: Error> Display for MachineError<E> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            MachineError::InvalidTransition => f.write_str("Invalid transition"),
+            MachineError::Underlying(e) => Display::fmt(&e, f),
+        }
+    }
+}
+impl<E: Error> Error for MachineError<E> {}
+
+pub enum MachineUpdate<Machine>
+where
+    Machine: StateMachine,
+{
+    InvalidTransition,
+    Ok { commands: Vec<Machine::Command> },
+}
+
+impl<M> MachineUpdate<M>
+where
+    M: StateMachine,
+{
+    /// Unwraps the machine update, panicking if the transition was invalid.
+    pub fn unwrap(self) -> Vec<M::Command> {
+        match self {
+            Self::Ok { commands } => commands,
+            Self::InvalidTransition => panic!("Transition was not successful!"),
+        }
+    }
+}
+
+/// A transition result is emitted every time the [StateMachine] handles an event.
+pub enum TransitionResult<Machine, DestinationState>
+where
+    Machine: StateMachine,
+    DestinationState: Into<Machine::State>,
+{
+    /// This state does not define a transition for this event from this state. All other errors
+    /// should use the [Err](enum.TransitionResult.html#variant.Err) variant.
+    InvalidTransition,
+    /// The transition was successful
+    Ok {
+        commands: Vec<Machine::Command>,
+        new_state: DestinationState,
+        shared_state: Machine::SharedState,
+    },
+    /// The transition was successful with no shared state change
+    OkNoShare {
+        commands: Vec<Machine::Command>,
+        new_state: DestinationState,
+    },
+    /// There was some error performing the transition
+    Err(Machine::Error),
+}
+
+impl<Sm, Ds> TransitionResult<Sm, Ds>
+where
+    Sm: StateMachine,
+    Ds: Into<Sm::State>,
+{
+    /// Produce a transition with the provided commands to the provided state. No changes to shared
+    /// state if it exists
+    pub fn ok<CI>(commands: CI, new_state: Ds) -> Self
+    where
+        CI: IntoIterator<Item = Sm::Command>,
+    {
+        Self::OkNoShare {
+            commands: commands.into_iter().collect(),
+            new_state,
+        }
+    }
+
+    /// Produce a transition with the provided commands to the provided state with shared state
+    /// changes
+    pub fn ok_shared<CI, SS>(commands: CI, new_state: Ds, new_shared: SS) -> Self
+    where
+        CI: IntoIterator<Item = Sm::Command>,
+        SS: Into<Sm::SharedState>,
+    {
+        Self::Ok {
+            commands: commands.into_iter().collect(),
+            new_state,
+            shared_state: new_shared.into(),
+        }
+    }
+
+    /// Uses `Into` to produce a transition with no commands from the provided current state to
+    /// the provided (by type parameter) destination state.
+    pub fn from<CurrentState>(current_state: CurrentState) -> Self
+    where
+        CurrentState: Into<Ds>,
+    {
+        let as_dest: Ds = current_state.into();
+        Self::OkNoShare {
+            commands: vec![],
+            new_state: as_dest,
+        }
+    }
+}
+
+impl<Sm, Ds> TransitionResult<Sm, Ds>
+where
+    Sm: StateMachine,
+    Ds: Into<Sm::State> + Default,
+{
+    /// Produce a transition with commands relying on [Default] for the destination state's value
+    pub fn commands<CI>(commands: CI) -> Self
+    where
+        CI: IntoIterator<Item = Sm::Command>,
+    {
+        Self::OkNoShare {
+            commands: commands.into_iter().collect(),
+            new_state: Ds::default(),
+        }
+    }
+
+    /// Produce a transition with no commands relying on [Default] for the destination state's
+    /// value
+    pub fn default() -> Self {
+        Self::OkNoShare {
+            commands: vec![],
+            new_state: Ds::default(),
+        }
+    }
+}
+
+impl<Sm, Ds> TransitionResult<Sm, Ds>
+where
+    Sm: StateMachine,
+    Ds: Into<Sm::State>,
+{
+    /// Turns more-specific (struct) transition result into more-general (enum) transition result
+    pub fn into_general(self) -> TransitionResult<Sm, Sm::State> {
+        match self {
+            TransitionResult::InvalidTransition => TransitionResult::InvalidTransition,
+            TransitionResult::Ok {
+                commands,
+                new_state,
+                shared_state,
+            } => TransitionResult::Ok {
+                commands,
+                new_state: new_state.into(),
+                shared_state,
+            },
+            TransitionResult::OkNoShare {
+                commands,
+                new_state,
+            } => TransitionResult::OkNoShare {
+                commands,
+                new_state: new_state.into(),
+            },
+            TransitionResult::Err(e) => TransitionResult::Err(e),
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+pub use rustfsm_procmacro::fsm;
+pub use rustfsm_trait::{MachineError, StateMachine, TransitionResult};

data/bridge/sdk-core/integ-with-otel.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+# Run integ tests with OTel collector export enabled
+export TEMPORAL_INTEG_OTEL_URL="grpc://localhost:4317"
+export TEMPORAL_TRACING_FILTER="temporal_sdk_core=DEBUG"
+
+cargo integ-test "${@:1}"

data/bridge/sdk-core/protos/api_upstream/README.md

@@ -0,0 +1,9 @@
+# Temporal proto files  
+
+## How to use
+
+Install as git submodule to the project.
+
+## License
+
+MIT License, please see [LICENSE](LICENSE) for details.

data/bridge/sdk-core/protos/api_upstream/api-linter.yaml

@@ -0,0 +1,40 @@
+- included_paths:
+    - '**/*.proto'
+  disabled_rules:
+    - 'core::0192::has-comments'
+
+- included_paths:
+    - '**/message.proto'
+  disabled_rules:
+    - 'core::0122::name-suffix'
+    - 'core::0123::resource-annotation'
+
+- included_paths:
+    - '**/workflowservice/v1/request_response.proto'
+    - '**/operatorservice/v1/request_response.proto'
+  disabled_rules:
+    - 'core::0122::name-suffix'
+    - 'core::0131::request-name-required'
+    - 'core::0131::request-unknown-fields'
+    - 'core::0132::request-parent-required'
+    - 'core::0132::request-unknown-fields'
+    - 'core::0132::response-unknown-fields'
+    - 'core::0134::request-unknown-fields'
+    - 'core::0158::request-page-size-field'
+    - 'core::0158::request-page-token-field'
+    - 'core::0158::response-next-page-token-field'
+    - 'core::0158::response-plural-first-field'
+    - 'core::0158::response-repeated-first-field'
+
+- included_paths:
+    - '**/workflowservice/v1/service.proto'
+    - '**/operatorservice/v1/service.proto'
+  disabled_rules:
+    - 'core::0127::http-annotation'
+    - 'core::0131::method-signature'
+    - 'core::0131::response-message-name'
+
+- included_paths:
+    - 'dependencies/gogoproto/gogo.proto'
+  disabled_rules:
+    - 'all'