@temporalio/core-bridge 1.9.2 → 1.10.0

package/sdk-core/core/src/worker/workflow/workflow_stream/saved_wf_inputs.rs

@@ -1,117 +0,0 @@
-use crate::{
-    telemetry::metrics::MetricsContext,
-    worker::{
-        client::mocks::DEFAULT_TEST_CAPABILITIES,
-        workflow::{
-            workflow_stream::{WFStream, WFStreamInput},
-            LAReqSink, LocalActivityRequestSink,
-        },
-        LocalActRequest, LocalActivityResolution,
-    },
-};
-use crossbeam_queue::SegQueue;
-use futures::Stream;
-use futures_util::StreamExt;
-use serde::{Deserialize, Serialize};
-use std::{future, sync::Arc};
-use temporal_sdk_core_api::worker::WorkerConfig;
-use tokio::sync::mpsc::UnboundedSender;
-use tokio_util::sync::CancellationToken;
-
-/// Replay everything that happened to internal workflow state. Useful for 100% deterministic
-/// reproduction of bugs.
-///
-/// Use `CoreWfStarter::enable_wf_state_input_recording` from the integration test utilities to
-/// activate saving the data to disk, and use the `wf_input_replay` example binary to replay.
-pub async fn replay_wf_state_inputs(config: WorkerConfig, inputs: impl Stream<Item = Vec<u8>>) {
-    use crate::worker::build_wf_basics;
-
-    let la_resp_q = Arc::new(SegQueue::new());
-    let la_resp_q_clone = la_resp_q.clone();
-    let inputs = inputs
-        .map(|bytes| {
-            rmp_serde::from_slice::<StoredWFStateInputDeSer>(&bytes)
-                .expect("Can decode wf stream input")
-        })
-        .filter_map(|si| {
-            future::ready(match si {
-                StoredWFStateInputDeSer::Stream(wfsi) => Some(wfsi),
-                StoredWFStateInputDeSer::ImmediateLASinkResolutions(lares) => {
-                    la_resp_q_clone.push(lares);
-                    None
-                }
-            })
-        });
-    let basics = build_wf_basics(
-        config,
-        MetricsContext::no_op(),
-        CancellationToken::new(),
-        DEFAULT_TEST_CAPABILITIES.clone(),
-    );
-    let sink = ReadingFromFileLaReqSink {
-        resolutions: la_resp_q,
-    };
-    info!("Beginning workflow stream internal state replay");
-    let stream = WFStream::build_internal(inputs, basics, sink);
-    stream
-        .for_each(|o| async move { trace!("Stream output: {:?}", o) })
-        .await;
-}
-
-impl WFStream {
-    pub(super) fn prep_input(&mut self, action: &WFStreamInput) -> Option<PreppedInputWrite> {
-        // Remove the channel, we'll put it back, avoiding a clone
-        self.wf_state_inputs.take().map(|chan| PreppedInputWrite {
-            data: rmp_serde::to_vec(&StoredWFStateInputSer::Stream(action))
-                .expect("WF Inputs are serializable"),
-            chan,
-        })
-    }
-    pub(super) fn flush_write(&mut self, w: PreppedInputWrite) {
-        let _ = w.chan.send(w.data);
-        self.wf_state_inputs = Some(w.chan);
-    }
-}
-pub(super) struct PreppedInputWrite {
-    data: Vec<u8>,
-    chan: UnboundedSender<Vec<u8>>,
-}
-
-#[derive(Serialize)]
-enum StoredWFStateInputSer<'a> {
-    Stream(&'a WFStreamInput),
-    ImmediateLASinkResolutions(&'a Vec<LocalActivityResolution>),
-}
-
-#[derive(Deserialize)]
-enum StoredWFStateInputDeSer {
-    Stream(WFStreamInput),
-    ImmediateLASinkResolutions(Vec<LocalActivityResolution>),
-}
-
-struct ReadingFromFileLaReqSink {
-    resolutions: Arc<SegQueue<Vec<LocalActivityResolution>>>,
-}
-impl LocalActivityRequestSink for ReadingFromFileLaReqSink {
-    fn sink_reqs(&self, reqs: Vec<LocalActRequest>) -> Vec<LocalActivityResolution> {
-        if !reqs.is_empty() {
-            self.resolutions
-                .pop()
-                .expect("LA sink was called, but there's no stored immediate response")
-        } else {
-            vec![]
-        }
-    }
-}
-
-impl LAReqSink {
-    pub(crate) fn write_req(&self, res: &Vec<LocalActivityResolution>) {
-        if let Some(r) = self.recorder.as_ref() {
-            r.send(
-                rmp_serde::to_vec(&StoredWFStateInputSer::ImmediateLASinkResolutions(res))
-                    .expect("LA immediate resolutions are serializable"),
-            )
-            .expect("WF input serialization channel is available for immediate LA result storage");
-        }
-    }
-}

package/sdk-core/core/src/worker/workflow/workflow_stream/tonic_status_serde.rs

@@ -1,24 +0,0 @@
-use tonic::{Code, Status};
-
-#[derive(serde::Serialize, serde::Deserialize)]
-#[serde(remote = "Status")]
-pub(super) struct SerdeStatus {
-    #[serde(getter = "get_code")]
-    code: i32,
-    #[serde(getter = "get_owned_msg")]
-    message: String,
-}
-
-fn get_owned_msg(v: &Status) -> String {
-    v.message().to_string()
-}
-
-fn get_code(v: &Status) -> i32 {
-    v.code() as i32
-}
-
-impl From<SerdeStatus> for Status {
-    fn from(v: SerdeStatus) -> Self {
-        Status::new(Code::from(v.code), v.message)
-    }
-}

package/sdk-core/sdk/src/payload_converter.rs

@@ -1,11 +0,0 @@
-//! Very much subject to change. Defines traits for converting inputs/outputs to/from payloads
-
-use serde::{Deserialize, Serialize};
-
-/// Something that can be deserialized from a payload. Currently just a pass-through to
-/// [Deserialize] which may actually be the best long-run choice.
-pub trait FromPayload<'de>: Deserialize<'de> {}
-
-/// Something that can be serialized into a payload. Currently just a pass-through to
-/// [Serialize] which may actually be the best long-run choice.
-pub trait IntoPayload: Serialize {}

package/sdk-core/sdk-core-protos/protos/api_upstream/.buildkite/Dockerfile

@@ -1,2 +0,0 @@
-FROM temporalio/base-ci-builder:1.10.3
-WORKDIR /temporal

package/sdk-core/sdk-core-protos/protos/api_upstream/.buildkite/docker-compose.yml

@@ -1,15 +0,0 @@
-version: "3.5"
-
-services:
-  build:
-    build:
-      context: ..
-      dockerfile: ./.buildkite/Dockerfile
-    environment:
-      - BUILDKITE_AGENT_ACCESS_TOKEN
-      - BUILDKITE_JOB_ID
-      - BUILDKITE_BUILD_ID
-      - BUILDKITE_BUILD_NUMBER
-    volumes:
-      - ../:/temporal
-      - /usr/bin/buildkite-agent:/usr/bin/buildkite-agent

package/sdk-core/sdk-core-protos/protos/api_upstream/.buildkite/pipeline.yml

@@ -1,10 +0,0 @@
-steps:
-  - label: "build"
-    agents:
-      queue: "default"
-      docker: "*"
-    command: "make ci-build"
-    plugins:
-      - docker-compose#v3.1.0:
-          run: build
-          config: ./.buildkite/docker-compose.yml

package/sdk-core/test-utils/src/wf_input_saver.rs

@@ -1,50 +0,0 @@
-use anyhow::anyhow;
-use bytes::BytesMut;
-use futures::{stream::BoxStream, SinkExt, StreamExt};
-use prost::bytes::Bytes;
-use std::path::Path;
-use temporal_sdk_core_api::worker::WorkerConfig;
-use tokio::{fs::File, sync::mpsc::UnboundedReceiver};
-use tokio_util::codec::{FramedRead, FramedWrite, LengthDelimitedCodec};
-
-pub struct WFStateReplayData {
-    pub config: WorkerConfig,
-    pub inputs: BoxStream<'static, Result<BytesMut, std::io::Error>>,
-}
-
-pub async fn stream_to_file(
-    config: &WorkerConfig,
-    mut rcv: UnboundedReceiver<Vec<u8>>,
-) -> Result<(), anyhow::Error> {
-    let file = File::create("wf_inputs").await?;
-    let mut transport = FramedWrite::new(file, ldc());
-    // First write the worker config, since things like cache size affect how many evictions there
-    // will be, etc.
-    transport.send(rmp_serde::to_vec(config)?.into()).await?;
-    while let Some(v) = rcv.recv().await {
-        transport.send(Bytes::from(v)).await?;
-    }
-    Ok(())
-}
-
-pub async fn read_from_file(path: impl AsRef<Path>) -> Result<WFStateReplayData, anyhow::Error> {
-    let file = File::open(path).await?;
-    let mut framed_read = FramedRead::new(file, ldc());
-    // Deserialize the worker config first
-    let config = framed_read
-        .next()
-        .await
-        .ok_or_else(|| anyhow!("Replay data file is empty"))??;
-    let config = rmp_serde::from_slice(config.as_ref())?;
-
-    Ok(WFStateReplayData {
-        config,
-        inputs: framed_read.boxed(),
-    })
-}
-
-fn ldc() -> LengthDelimitedCodec {
-    LengthDelimitedCodec::builder()
-        .length_field_type::<u16>()
-        .new_codec()
-}

package/sdk-core/tests/wf_input_replay.rs

@@ -1,32 +0,0 @@
-use anyhow::Context;
-use clap::Parser;
-use futures_util::StreamExt;
-use std::path::PathBuf;
-use temporal_sdk_core::replay_wf_state_inputs;
-use temporal_sdk_core_test_utils::{init_integ_telem, wf_input_saver::read_from_file};
-
-#[derive(clap::Parser)]
-#[command(author, version, about, long_about = None)]
-struct Cli {
-    /// Path to file containing the saved wf input data
-    replay_data: PathBuf,
-}
-
-#[tokio::main]
-async fn main() -> Result<(), anyhow::Error> {
-    init_integ_telem();
-    let Cli { replay_data } = Cli::parse();
-    let replay_dat = read_from_file(replay_data)
-        .await
-        .context("while reading replay data file")?;
-
-    replay_wf_state_inputs(
-        replay_dat.config,
-        replay_dat
-            .inputs
-            .map(|r| r.expect("Reading bytes from file works").to_vec()),
-    )
-    .await;
-
-    Ok(())
-}