@temporalio/core-bridge 0.19.2 → 0.20.2

package/sdk-core/client/src/mocks.rs

@@ -1,167 +0,0 @@
-//! Helpers for mocking
-
-use super::*;
-use crate::{MockServerGatewayApis, ServerGatewayOptions, ServerGatewayOptionsBuilder};
-use std::str::FromStr;
-use url::Url;
-
-/// Create a mock client primed with basic necessary expectations
-pub fn mock_gateway() -> MockServerGatewayApis {
-    let mut mg = MockServerGatewayApis::new();
-    mg.expect_get_options().return_const(fake_sg_opts());
-    mg
-}
-
-/// Create a mock manual client primed with basic necessary expectations
-pub fn mock_manual_gateway() -> MockManualGateway {
-    let mut mg = MockManualGateway::new();
-    mg.expect_get_options().return_const(fake_sg_opts());
-    mg
-}
-
-/// Returns some totally fake client options for use with mock clients
-pub fn fake_sg_opts() -> ServerGatewayOptions {
-    ServerGatewayOptionsBuilder::default()
-        .target_url(Url::from_str("https://fake").unwrap())
-        .namespace("test_namespace".to_string())
-        .client_name("fake_client".to_string())
-        .client_version("fake_version".to_string())
-        .worker_binary_id("fake_binid".to_string())
-        .build()
-        .unwrap()
-}
-
-// Need a version of the mock that can return futures so we can return potentially pending
-// results. This is really annoying b/c of the async trait stuff. Need
-// https://github.com/asomers/mockall/issues/189 to be fixed for it to go away.
-mockall::mock! {
-    pub ManualGateway {}
-    impl ServerGatewayApis for ManualGateway {
-        fn start_workflow<'a, 'b>(
-            &self,
-            input: Vec<Payload>,
-            task_queue: String,
-            workflow_id: String,
-            workflow_type: String,
-            task_timeout: Option<Duration>,
-        ) -> impl Future<Output = Result<StartWorkflowExecutionResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn poll_workflow_task<'a, 'b>(&'a self, task_queue: String, is_sticky: bool)
-            -> impl Future<Output = Result<PollWorkflowTaskQueueResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn poll_activity_task<'a, 'b>(&self, task_queue: String)
-            -> impl Future<Output = Result<PollActivityTaskQueueResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn reset_sticky_task_queue<'a, 'b>(
-            &self,
-            workflow_id: String,
-            run_id: String,
-        ) -> impl Future<Output = Result<ResetStickyTaskQueueResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn complete_workflow_task<'a, 'b>(
-            &self,
-            request: WorkflowTaskCompletion,
-        ) -> impl Future<Output = Result<RespondWorkflowTaskCompletedResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn complete_activity_task<'a, 'b>(
-            &self,
-            task_token: TaskToken,
-            result: Option<Payloads>,
-        ) -> impl Future<Output = Result<RespondActivityTaskCompletedResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn cancel_activity_task<'a, 'b>(
-            &self,
-            task_token: TaskToken,
-            details: Option<Payloads>,
-        ) -> impl Future<Output = Result<RespondActivityTaskCanceledResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn fail_activity_task<'a, 'b>(
-            &self,
-            task_token: TaskToken,
-            failure: Option<Failure>,
-        ) -> impl Future<Output = Result<RespondActivityTaskFailedResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn fail_workflow_task<'a, 'b>(
-            &self,
-            task_token: TaskToken,
-            cause: WorkflowTaskFailedCause,
-            failure: Option<Failure>,
-        ) -> impl Future<Output = Result<RespondWorkflowTaskFailedResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn signal_workflow_execution<'a, 'b>(
-            &self,
-            workflow_id: String,
-            run_id: String,
-            signal_name: String,
-            payloads: Option<Payloads>,
-        ) -> impl Future<Output = Result<SignalWorkflowExecutionResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn record_activity_heartbeat<'a, 'b>(
-           &self,
-           task_token: TaskToken,
-           details: Option<Payloads>,
-        ) -> impl Future<Output = Result<RecordActivityTaskHeartbeatResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn query_workflow_execution<'a, 'b>(
-            &self,
-            workflow_id: String,
-            run_id: String,
-            query: WorkflowQuery,
-        ) -> impl Future<Output = Result<QueryWorkflowResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn describe_workflow_execution<'a, 'b>(
-            &self,
-            workflow_id: String,
-            run_id: Option<String>,
-        ) -> impl Future<Output = Result<DescribeWorkflowExecutionResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn get_workflow_execution_history<'a, 'b>(
-            &self,
-            workflow_id: String,
-            run_id: Option<String>,
-            page_token: Vec<u8>
-        ) -> impl Future<Output = Result<GetWorkflowExecutionHistoryResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn respond_legacy_query<'a, 'b>(
-            &self,
-            task_token: TaskToken,
-            query_result: QueryResult,
-        ) -> impl Future<Output = Result<RespondQueryTaskCompletedResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn cancel_workflow_execution<'a, 'b>(
-            &self,
-            workflow_id: String,
-            run_id: Option<String>,
-        ) -> impl Future<Output = Result<RequestCancelWorkflowExecutionResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn terminate_workflow_execution<'a, 'b>(
-            &self,
-            workflow_id: String,
-            run_id: Option<String>,
-        ) -> impl Future<Output = Result<TerminateWorkflowExecutionResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn list_namespaces<'a, 'b>(
-            &self,
-        ) -> impl Future<Output = Result<ListNamespacesResponse>> + Send + 'b
-            where 'a: 'b, Self: 'b;
-
-        fn get_options(&self) -> &ServerGatewayOptions;
-    }
-}

package/sdk-core/core/src/worker/dispatcher.rs

@@ -1,171 +0,0 @@
-use crate::{
-    telemetry::metrics::{task_queue, MetricsContext},
-    worker::Worker,
-    WorkerConfig, WorkerLookupErr, WorkerRegistrationError,
-};
-use arc_swap::ArcSwap;
-use futures::future::join_all;
-use std::{collections::HashMap, ops::Deref, option::Option, sync::Arc};
-use temporal_client::ServerGatewayApis;
-use tokio::sync::Notify;
-
-/// Allows access to workers by task queue name
-#[derive(Default)]
-pub(crate) struct WorkerDispatcher {
-    /// Maps task queue names to workers. If the value is `None` then the worker existed at one
-    /// point and was shut down.
-    workers: ArcSwap<HashMap<String, Option<WorkerRefCt>>>,
-}
-
-impl WorkerDispatcher {
-    pub fn new_worker(
-        &self,
-        config: WorkerConfig,
-        sticky_queue: Option<String>,
-        gateway: Arc<dyn ServerGatewayApis + Send + Sync>,
-        parent_metrics: MetricsContext,
-    ) -> Result<(), WorkerRegistrationError> {
-        let tq = config.task_queue.clone();
-        let metrics = parent_metrics.with_new_attrs([task_queue(config.task_queue.clone())]);
-        let worker = Worker::new(config, sticky_queue, gateway, metrics);
-        self.set_worker_for_task_queue(tq, worker)
-    }
-
-    pub fn set_worker_for_task_queue(
-        &self,
-        tq: String,
-        worker: Worker,
-    ) -> Result<(), WorkerRegistrationError> {
-        if self
-            .workers
-            .load()
-            .get(&tq)
-            .map(Option::is_some)
-            .unwrap_or_default()
-        {
-            return Err(WorkerRegistrationError::WorkerAlreadyRegisteredForQueue(tq));
-        }
-        let tq = &tq;
-        let worker = WorkerRefCt::new(worker);
-        self.workers.rcu(|map| {
-            let mut map = HashMap::clone(map);
-            map.insert(tq.clone(), Some(worker.clone()));
-            map
-        });
-        Ok(())
-    }
-
-    pub fn get(&self, task_queue: &str) -> Result<impl Deref<Target = Worker>, WorkerLookupErr> {
-        if let Some(w) = self.workers.load().get(task_queue) {
-            if let Some(w) = w {
-                Ok(w.clone())
-            } else {
-                Err(WorkerLookupErr::Shutdown(task_queue.to_string()))
-            }
-        } else {
-            Err(WorkerLookupErr::NoWorker(task_queue.to_string()))
-        }
-    }
-
-    pub async fn shutdown_one(&self, task_queue: &str) {
-        info!("Shutting down worker on queue {}", task_queue);
-        let mut maybe_worker = None;
-        if let Some(stored_worker) = self.workers.load().get(task_queue) {
-            if let Some(w) = stored_worker {
-                w.shutdown().await;
-            }
-            self.workers.rcu(|map| {
-                let mut map = HashMap::clone(map);
-                if maybe_worker.is_none() {
-                    maybe_worker = map.get_mut(task_queue).and_then(Option::take);
-                }
-                map
-            });
-        }
-        if let Some(w) = maybe_worker {
-            w.destroy().await;
-        }
-    }
-
-    pub async fn shutdown_all(&self) {
-        // First notify all workers and allow tasks to drain
-        join_all(self.workers.load().values().map(|w| async move {
-            if let Some(w) = w {
-                w.shutdown().await;
-            }
-        }))
-        .await;
-
-        let mut all_workers = vec![];
-        self.workers.rcu(|map| {
-            let mut map = HashMap::clone(map);
-            for worker in map.values_mut() {
-                all_workers.push(worker.take());
-            }
-            map
-        });
-        join_all(all_workers.into_iter().map(|w| async move {
-            if let Some(w) = w {
-                w.destroy().await;
-            }
-        }))
-        .await;
-    }
-}
-
-/// Fun little struct that allows us to efficiently `await` for outstanding references to workers
-/// to reach 0 before we consume it forever.
-#[derive(Clone)]
-struct WorkerRefCt {
-    inner: Option<Arc<Worker>>,
-    notify: Arc<Notify>,
-}
-
-impl WorkerRefCt {
-    fn new(worker: Worker) -> Self {
-        Self {
-            inner: Some(Arc::new(worker)),
-            notify: Arc::new(Notify::new()),
-        }
-    }
-
-    async fn destroy(mut self) {
-        let mut arc = self.inner.take().unwrap();
-        loop {
-            self.notify.notified().await;
-            match Arc::try_unwrap(arc) {
-                Ok(w) => {
-                    w.finalize_shutdown().await;
-                    return;
-                }
-                Err(a) => {
-                    arc = a;
-                    continue;
-                }
-            }
-        }
-    }
-}
-
-impl Deref for WorkerRefCt {
-    type Target = Worker;
-
-    fn deref(&self) -> &Self::Target {
-        self.inner.as_deref().expect("Must exist")
-    }
-}
-
-impl Drop for WorkerRefCt {
-    fn drop(&mut self) {
-        match &self.inner {
-            // Notify once destroy has been requested
-            None => self.notify.notify_one(),
-            Some(arc) => {
-                // We wait until 2 rather than 1 because we ourselves still have an Arc
-                if Arc::strong_count(arc) == 2 {
-                    self.notify.notify_one();
-                }
-            }
-        };
-    }
-}

package/sdk-core/protos/local/temporal/sdk/core/bridge/service.proto

@@ -1,61 +0,0 @@
-syntax = "proto3";
-
-package coresdk.bridge;
-
-import "temporal/sdk/core/bridge/bridge.proto";
-
-service Bridge {
-  // Starts an isolated core instance unique to this stream that will
-  // automatically be shutdown on completion of the stream. The caller must
-  // provide the first message and it must be an "init". No other calls can be
-  // made until the init response has been received by the client.
-  //
-  // Every request message will have a single correlated response message,
-  // though not necessarily in a particular order or timeframe.
-  //
-  // There is no requst for "shutdown", because it is implied on stream
-  // completion.
-  //
-  // The stream approach is chosen because core is inherently stateful while
-  // gRPC unary RPCs are not. Upon abnormal stream close, the caller should
-  // reattempt, performing the init again.
-  rpc Stream(stream StreamRequest) returns (stream StreamResponse);
-}
-
-message StreamRequest {
-  // The ID sent in the response. This is not technically required nor must it
-  // be unique if the caller, say, knows they only have one message outstanding
-  // of a certain type. However, it is recommended that this always be present
-  // and unique to avoid confusion.
-  string id = 1;
-
-  oneof request {
-    InitRequest init = 2;
-    RegisterWorkerRequest register_worker = 3;
-    PollWorkflowActivationRequest poll_workflow_activation = 4;
-    PollActivityTaskRequest poll_activity_task = 5;
-    CompleteWorkflowActivationRequest complete_workflow_activation = 6;
-    CompleteActivityTaskRequest complete_activity_task = 7;
-    RecordActivityHeartbeatRequest record_activity_heartbeat = 8;
-    RequestWorkflowEvictionRequest request_workflow_eviction = 9;
-    ShutdownWorkerRequest shutdown_worker = 10;
-    FetchBufferedLogsRequest fetch_buffered_logs = 11;
-  }
-}
-
-message StreamResponse {
-  string request_id = 1;
-
-  oneof response {
-    InitResponse init = 2;
-    RegisterWorkerResponse register_worker = 3;
-    PollWorkflowActivationResponse poll_workflow_activation = 4;
-    PollActivityTaskResponse poll_activity_task = 5;
-    CompleteWorkflowActivationResponse complete_workflow_activation = 6;
-    CompleteActivityTaskResponse complete_activity_task = 7;
-    RecordActivityHeartbeatResponse record_activity_heartbeat = 8;
-    RequestWorkflowEvictionResponse request_workflow_eviction = 9;
-    ShutdownWorkerResponse shutdown_worker = 10;
-    FetchBufferedLogsResponse fetch_buffered_logs = 11;
-  }
-}