@temporalio/core-bridge 1.1.0 → 1.3.1

package/sdk-core/core/src/ephemeral_server/mod.rs

@@ -0,0 +1,499 @@
+//! This module implements support for downloading and running ephemeral test
+//! servers useful for testing.
+
+use anyhow::anyhow;
+use flate2::read::GzDecoder;
+use futures::StreamExt;
+use serde::Deserialize;
+use std::{
+    fs::OpenOptions,
+    path::{Path, PathBuf},
+};
+use temporal_client::ClientOptionsBuilder;
+use tokio::{
+    task::spawn_blocking,
+    time::{sleep, Duration},
+};
+use tokio_util::io::{StreamReader, SyncIoBridge};
+use url::Url;
+use zip::read::read_zipfile_from_stream;
+
+#[cfg(target_family = "unix")]
+use std::os::unix::fs::OpenOptionsExt;
+
+/// Configuration for Temporalite.
+#[derive(Debug, Clone, derive_builder::Builder)]
+pub struct TemporaliteConfig {
+    /// Required path to executable or download info.
+    pub exe: EphemeralExe,
+    /// Namespace to use.
+    #[builder(default = "\"default\".to_owned()")]
+    pub namespace: String,
+    /// IP to bind to.
+    #[builder(default = "\"127.0.0.1\".to_owned()")]
+    pub ip: String,
+    /// Port to use or obtains a free one if none given.
+    #[builder(default)]
+    pub port: Option<u16>,
+    /// Sqlite DB filename if persisting or non-persistent if none.
+    #[builder(default)]
+    pub db_filename: Option<String>,
+    /// Whether to enable the UI.
+    #[builder(default)]
+    pub ui: bool,
+    /// Log format and level
+    #[builder(default = "(\"pretty\".to_owned(), \"warn\".to_owned())")]
+    pub log: (String, String),
+    /// Additional arguments to Temporalite.
+    #[builder(default)]
+    pub extra_args: Vec<String>,
+}
+
+impl TemporaliteConfig {
+    /// Start a Temporalite server.
+    pub async fn start_server(&self) -> anyhow::Result<EphemeralServer> {
+        // Get exe path
+        let exe_path = self.exe.get_or_download("temporalite").await?;
+
+        // Get free port if not already given
+        let port = self.port.unwrap_or_else(|| get_free_port(&self.ip));
+
+        // Build arg set
+        let mut args = vec![
+            "start".to_owned(),
+            "--port".to_owned(),
+            port.to_string(),
+            "--namespace".to_owned(),
+            self.namespace.clone(),
+            "--ip".to_owned(),
+            self.ip.clone(),
+            "--log-format".to_owned(),
+            self.log.0.clone(),
+            "--log-level".to_owned(),
+            self.log.1.clone(),
+        ];
+        if let Some(db_filename) = &self.db_filename {
+            args.push("--filename".to_owned());
+            args.push(db_filename.clone());
+        } else {
+            args.push("--ephemeral".to_owned());
+        }
+        if !self.ui {
+            args.push("--headless".to_owned());
+        }
+        args.extend(self.extra_args.clone());
+
+        // Start
+        EphemeralServer::start(EphemeralServerConfig {
+            exe_path,
+            port,
+            args,
+            has_test_service: false,
+        })
+        .await
+    }
+}
+
+/// Configuration for the test server.
+#[derive(Debug, Clone, derive_builder::Builder)]
+pub struct TestServerConfig {
+    /// Required path to executable or download info.
+    pub exe: EphemeralExe,
+    /// Port to use or obtains a free one if none given.
+    #[builder(default)]
+    pub port: Option<u16>,
+    /// Additional arguments to the test server.
+    #[builder(default)]
+    pub extra_args: Vec<String>,
+}
+
+impl TestServerConfig {
+    /// Start a test server.
+    pub async fn start_server(&self) -> anyhow::Result<EphemeralServer> {
+        // Get exe path
+        let exe_path = self.exe.get_or_download("temporal-test-server").await?;
+
+        // Get free port if not already given
+        let port = self.port.unwrap_or_else(|| get_free_port("0.0.0.0"));
+
+        // Build arg set
+        let mut args = vec![port.to_string()];
+        args.extend(self.extra_args.clone());
+
+        // Start
+        EphemeralServer::start(EphemeralServerConfig {
+            exe_path,
+            port,
+            args,
+            has_test_service: true,
+        })
+        .await
+    }
+}
+
+struct EphemeralServerConfig {
+    exe_path: PathBuf,
+    port: u16,
+    args: Vec<String>,
+    has_test_service: bool,
+}
+
+/// Server that will be stopped when dropped.
+pub struct EphemeralServer {
+    /// gRPC target host:port for the server frontend.
+    pub target: String,
+    /// Whether the target implements the gRPC TestService
+    pub has_test_service: bool,
+    child: tokio::process::Child,
+}
+
+impl EphemeralServer {
+    async fn start(config: EphemeralServerConfig) -> anyhow::Result<EphemeralServer> {
+        // Start process
+        // TODO(cretz): Offer stdio suppression?
+        let child = tokio::process::Command::new(config.exe_path)
+            .args(config.args)
+            .stdin(std::process::Stdio::null())
+            .spawn()?;
+        let target = format!("127.0.0.1:{}", config.port);
+        let target_url = format!("http://{}", target);
+        let success = Ok(EphemeralServer {
+            target,
+            has_test_service: config.has_test_service,
+            child,
+        });
+
+        // Try to connect every 100ms for 5s
+        // TODO(cretz): Some other way, e.g. via stdout, to know whether the
+        // server is up?
+        let client_options = ClientOptionsBuilder::default()
+            .identity("online_checker".to_owned())
+            .target_url(Url::parse(&target_url)?)
+            .client_name("online-checker".to_owned())
+            .client_version("0.1.0".to_owned())
+            .build()?;
+        for _ in 0..50 {
+            sleep(Duration::from_millis(100)).await;
+            if client_options
+                .connect_no_namespace(None, None)
+                .await
+                .is_ok()
+            {
+                return success;
+            }
+        }
+        Err(anyhow!("Failed connecting to test server after 5 seconds"))
+    }
+
+    /// Shutdown the server (i.e. kill the child process). This does not attempt
+    /// a kill if the child process appears completed, but such a check is not
+    /// atomic so a kill could still fail as completed if completed just before
+    /// kill.
+    #[cfg(not(target_family = "unix"))]
+    pub async fn shutdown(&mut self) -> anyhow::Result<()> {
+        // Only kill if there is a PID
+        if self.child.id().is_some() {
+            Ok(self.child.kill().await?)
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Shutdown the server (i.e. kill the child process). This does not attempt
+    /// a kill if the child process appears completed, but such a check is not
+    /// atomic so a kill could still fail as completed if completed just before
+    /// kill.
+    #[cfg(target_family = "unix")]
+    pub async fn shutdown(&mut self) -> anyhow::Result<()> {
+        // For whatever reason, Tokio is not properly waiting on result
+        // after sending kill in some cases which is causing defunct zombie
+        // processes to remain and kill() to hang. Therefore, we are sending
+        // SIGINT and waiting on the process ourselves using a low-level call.
+        //
+        // WARNING: This is based on empirical evidence starting a Python test
+        // run on Linux with Python 3.7 (does not happen on Python 3.10 nor does
+        // it happen on Temporalite nor does it happen in Rust integration
+        // tests). Do not consider this fixed without running that scenario.
+        if let Some(pid) = self.child.id() {
+            let nix_pid = nix::unistd::Pid::from_raw(pid as i32);
+            Ok(spawn_blocking(move || {
+                nix::sys::signal::kill(nix_pid, nix::sys::signal::Signal::SIGINT)?;
+                nix::sys::wait::waitpid(Some(nix_pid), None)
+            })
+            .await?
+            .map(|_| ())?)
+        } else {
+            Ok(())
+        }
+    }
+}
+
+/// Where to find an executable. Can be a path or download.
+#[derive(Debug, Clone)]
+pub enum EphemeralExe {
+    /// Existing path on the filesystem for the executable.
+    ExistingPath(String),
+    /// Download the executable if not already there.
+    CachedDownload {
+        /// Which version to download.
+        version: EphemeralExeVersion,
+        /// Destination directory or the user temp directory if none set.
+        dest_dir: Option<String>,
+    },
+}
+
+/// Which version of the exe to download.
+#[derive(Debug, Clone)]
+pub enum EphemeralExeVersion {
+    /// Use a default version for the given SDK name and version.
+    Default {
+        /// Name of the SDK to get the default for.
+        sdk_name: String,
+        /// Version of the SDK to get the default for.
+        sdk_version: String,
+    },
+    /// Specific version.
+    Fixed(String),
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+struct DownloadInfo {
+    archive_url: String,
+    file_to_extract: String,
+}
+
+impl EphemeralExe {
+    async fn get_or_download(&self, artifact_name: &str) -> anyhow::Result<PathBuf> {
+        match self {
+            EphemeralExe::ExistingPath(exe_path) => {
+                let path = PathBuf::from(exe_path);
+                if !path.exists() {
+                    return Err(anyhow!("Exe path does not exist"));
+                }
+                Ok(path)
+            }
+            EphemeralExe::CachedDownload { version, dest_dir } => {
+                let dest_dir = dest_dir
+                    .as_ref()
+                    .map(PathBuf::from)
+                    .unwrap_or_else(std::env::temp_dir);
+                let (platform, out_ext) = match std::env::consts::OS {
+                    "windows" => ("windows", ".exe"),
+                    "macos" => ("darwin", ""),
+                    _ => ("linux", ""),
+                };
+                // Create dest file based on SDK name/version or fixed version
+                let dest = dest_dir.join(match version {
+                    EphemeralExeVersion::Default {
+                        sdk_name,
+                        sdk_version,
+                    } => format!("{}-{}-{}{}", artifact_name, sdk_name, sdk_version, out_ext),
+                    EphemeralExeVersion::Fixed(version) => {
+                        format!("{}-{}{}", artifact_name, version, out_ext)
+                    }
+                });
+                debug!(
+                    "Lazily downloading or using existing exe at {}",
+                    dest.display()
+                );
+
+                // If it already exists, skip
+                if dest.exists() {
+                    return Ok(dest);
+                }
+
+                // Get info about the proper archive and in-archive file
+                let arch = match std::env::consts::ARCH {
+                    "x86_64" => "amd64",
+                    "arm" | "aarch64" => "arm64",
+                    other => return Err(anyhow!("Unsupported arch: {}", other)),
+                };
+                let mut get_info_params = vec![("arch", arch), ("platform", platform)];
+                let version_name = match version {
+                    EphemeralExeVersion::Default {
+                        sdk_name,
+                        sdk_version,
+                    } => {
+                        get_info_params.push(("sdk-name", sdk_name.as_str()));
+                        get_info_params.push(("sdk-version", sdk_version.as_str()));
+                        "default"
+                    }
+                    EphemeralExeVersion::Fixed(version) => version,
+                };
+                let client = reqwest::Client::new();
+                let info: DownloadInfo = client
+                    .get(format!(
+                        "https://temporal.download/{}/{}",
+                        artifact_name, version_name
+                    ))
+                    .query(&get_info_params)
+                    .send()
+                    .await?
+                    .json()
+                    .await?;
+
+                // Attempt download, looping because it could have waited for
+                // concurrent one to finish
+                loop {
+                    if lazy_download_exe(
+                        &client,
+                        &info.archive_url,
+                        Path::new(&info.file_to_extract),
+                        &dest,
+                    )
+                    .await?
+                    {
+                        return Ok(dest);
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn get_free_port(bind_ip: &str) -> u16 {
+    // Can just ask OS to give us a port then close socket. OS's don't give that
+    // port back to anyone else anytime soon.
+    std::net::TcpListener::bind(format!("{}:0", bind_ip))
+        .unwrap()
+        .local_addr()
+        .unwrap()
+        .port()
+}
+
+/// Returns false if we successfully waited for another download to complete, or
+/// true if the destination is known to exist. Should call again if false is
+/// returned.
+async fn lazy_download_exe(
+    client: &reqwest::Client,
+    uri: &str,
+    file_to_extract: &Path,
+    dest: &Path,
+) -> anyhow::Result<bool> {
+    // If it already exists, do not extract
+    if dest.exists() {
+        return Ok(true);
+    }
+
+    // We only want to download if we're not already downloading. To avoid some
+    // kind of global lock, we'll just create the file eagerly w/ a temp
+    // filename and delete it on failure or move it on success. If the temp file
+    // already exists, we'll wait a bit and re-run this.
+    let temp_dest_str = format!("{}{}", dest.to_str().unwrap(), ".downloading");
+    let temp_dest = Path::new(&temp_dest_str);
+    // Try to open file, using a file mode on unix families
+    #[cfg(target_family = "unix")]
+    let file = OpenOptions::new()
+        .create_new(true)
+        .write(true)
+        .mode(0o755)
+        .open(temp_dest);
+    #[cfg(not(target_family = "unix"))]
+    let file = OpenOptions::new()
+        .create_new(true)
+        .write(true)
+        .open(temp_dest);
+    // This match only gets Ok if the file was downloaded and extracted to the
+    // temporary path
+    match file {
+        Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => {
+            // Since it already exists, we'll try once a second for 20 seconds
+            // to wait for it to be done, then return false so the caller can
+            // try again.
+            for _ in 0..20 {
+                sleep(Duration::from_secs(1)).await;
+                if !temp_dest.exists() {
+                    return Ok(false);
+                }
+            }
+            Err(anyhow!(
+                "Temp download file at {} not complete after 20 seconds. \
+                Make sure another download isn't running for too long and delete the temp file.",
+                temp_dest.display()
+            ))
+        }
+        Err(err) => Err(err.into()),
+        // If the dest was added since, just remove temp file
+        Ok(_) if dest.exists() => {
+            std::fs::remove_file(temp_dest)?;
+            return Ok(true);
+        }
+        // Download and extract the binary
+        Ok(mut temp_file) => {
+            info!("Downloading {} to {}", uri, dest.display());
+            download_and_extract(client, uri, file_to_extract, &mut temp_file)
+                .await
+                .map_err(|err| {
+                    // Failed to download, just remove file
+                    if let Err(err) = std::fs::remove_file(temp_dest) {
+                        warn!(
+                            "Failed removing temp file at {}: {:?}",
+                            temp_dest.display(),
+                            err
+                        );
+                    }
+                    err
+                })
+        }
+    }?;
+    // Now that file should be dropped, we can rename
+    std::fs::rename(temp_dest, dest)?;
+    Ok(true)
+}
+
+async fn download_and_extract(
+    client: &reqwest::Client,
+    uri: &str,
+    file_to_extract: &Path,
+    dest: &mut std::fs::File,
+) -> anyhow::Result<()> {
+    // Start download. We are using streaming here to extract the file from the
+    // tarball or zip instead of loading into memory for Cursor/Seek.
+    let resp = client.get(uri).send().await?;
+    // We have to map the error type to an io error
+    let stream = resp
+        .bytes_stream()
+        .map(|item| item.map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err)));
+
+    // Since our tar/zip impls use sync IO, we have to create a bridge and run
+    // in a blocking closure.
+    let mut reader = SyncIoBridge::new(StreamReader::new(stream));
+    let tarball = if uri.ends_with(".tar.gz") {
+        true
+    } else if uri.ends_with(".zip") {
+        false
+    } else {
+        return Err(anyhow!("URI not .tar.gz or .zip"));
+    };
+    let file_to_extract = file_to_extract.to_path_buf();
+    let mut dest = dest.try_clone()?;
+
+    spawn_blocking(move || {
+        if tarball {
+            for entry in tar::Archive::new(GzDecoder::new(reader)).entries()? {
+                let mut entry = entry?;
+                if entry.path()? == file_to_extract {
+                    std::io::copy(&mut entry, &mut dest)?;
+                    return Ok(());
+                }
+            }
+            Err(anyhow!("Unable to find file in tarball"))
+        } else {
+            loop {
+                // This is the way to stream a zip file without creating an archive
+                // that requires Seek.
+                if let Some(mut file) = read_zipfile_from_stream(&mut reader)? {
+                    // If this is the file we're expecting, extract it
+                    if file.enclosed_name() == Some(&file_to_extract) {
+                        std::io::copy(&mut file, &mut dest)?;
+                        return Ok(());
+                    }
+                } else {
+                    return Err(anyhow!("Unable to find file in zip"));
+                }
+            }
+        }
+    })
+    .await?
+}

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

@@ -12,6 +12,7 @@ extern crate tracing;
 extern crate core;
 
 mod abstractions;
+pub mod ephemeral_server;
 mod log_export;
 mod pollers;
 mod protosext;
@@ -48,7 +49,7 @@ use crate::{
     worker::client::WorkerClientBag,
 };
 use std::sync::Arc;
-use temporal_client::AnyClient;
+use temporal_client::{ConfiguredClient, TemporalServiceClientWithMetrics};
 use temporal_sdk_core_api::{
     errors::{CompleteActivityError, PollActivityError, PollWfError},
     CoreLog, Worker as WorkerTrait,
@@ -58,46 +59,43 @@ use temporal_sdk_core_protos::{coresdk::ActivityHeartbeat, temporal::api::histor
 lazy_static::lazy_static! {
     /// A process-wide unique string, which will be different on every startup
     static ref PROCCESS_UNIQ_ID: String = {
-        uuid::Uuid::new_v4().to_simple().to_string()
+        uuid::Uuid::new_v4().simple().to_string()
     };
 }
 
 /// Initialize a worker bound to a task queue.
 ///
-/// Lang implementations should pass in a a [temporal_client::ConfiguredClient] directly (or a
-/// [RetryClient] wrapping one). When they do so, this function will always overwrite the client
-/// retry configuration, force the client to use the namespace defined in the worker config, and set
-/// the client identity appropriately. IE: Use [ClientOptions::connect_no_namespace], not
-/// [ClientOptions::connect].
-///
-/// It is also possible to pass in a [WorkflowClientTrait] implementor, but this largely exists to
-/// support testing and mocking. Lang impls should not operate that way, as it may result in
-/// improper retry behavior for a worker.
+/// Lang implementations may pass in a [temporal_client::ConfiguredClient] directly (or a
+/// [RetryClient] wrapping one, or a handful of other variants of the same idea). When they do so,
+/// this function will always overwrite the client retry configuration, force the client to use the
+/// namespace defined in the worker config, and set the client identity appropriately. IE: Use
+/// [ClientOptions::connect_no_namespace], not [ClientOptions::connect].
 pub fn init_worker<CT>(worker_config: WorkerConfig, client: CT) -> Worker
 where
-    CT: Into<AnyClient>,
+    CT: Into<sealed::AnyClient>,
 {
-    let as_enum = client.into();
-    let client = match as_enum {
-        AnyClient::HighLevel(ac) => ac,
-        AnyClient::LowLevel(ll) => {
-            let mut client = Client::new(*ll, worker_config.namespace.clone());
-            client.set_worker_build_id(worker_config.worker_build_id.clone());
-            if let Some(ref id_override) = worker_config.client_identity_override {
-                client.options_mut().identity = id_override.clone();
-            }
-            let retry_client = RetryClient::new(client, Default::default());
-            Arc::new(retry_client)
+    let client = {
+        let ll = client.into().into_inner();
+        let mut client = Client::new(*ll, worker_config.namespace.clone());
+        client.set_worker_build_id(worker_config.worker_build_id.clone());
+        if let Some(ref id_override) = worker_config.client_identity_override {
+            client.options_mut().identity = id_override.clone();
         }
+        RetryClient::new(client, RetryConfig::default())
     };
     if client.namespace() != worker_config.namespace {
         panic!("Passed in client is not bound to the same namespace as the worker");
     }
-    let sticky_q = sticky_q_name_for_worker(&client.get_options().identity, &worker_config);
+    let client_ident = client.get_options().identity.clone();
+    let sticky_q = sticky_q_name_for_worker(&client_ident, &worker_config);
     let client_bag = Arc::new(WorkerClientBag::new(
-        Box::new(client),
+        client,
         worker_config.namespace.clone(),
+        client_ident,
+        worker_config.worker_build_id.clone(),
+        worker_config.use_worker_versioning,
     ));
+
     let metrics = MetricsContext::top_level(worker_config.namespace.clone())
         .with_task_q(worker_config.task_queue.clone());
     Worker::new(worker_config, sticky_q, client_bag, metrics)
@@ -118,7 +116,7 @@ pub fn init_replay_worker(
     config.max_concurrent_wft_polls = 1;
     config.no_remote_activities = true;
     // Could possibly just use mocked pollers here?
-    let client = mock_client_from_history(history, &config.task_queue);
+    let client = mock_client_from_history(history, config.task_queue.clone());
     let run_id = history.extract_run_id_from_start()?.to_string();
     let last_event = history.last_event_id();
     let mut worker = Worker::new(config, None, Arc::new(client), MetricsContext::default());
@@ -139,3 +137,39 @@ pub(crate) fn sticky_q_name_for_worker(
         None
     }
 }
+
+mod sealed {
+    use super::*;
+
+    /// Allows passing different kinds of clients into things that want to be flexible. Motivating
+    /// use-case was worker initialization.
+    ///
+    /// Needs to exist in this crate to avoid blanket impl conflicts.
+    pub struct AnyClient(Box<ConfiguredClient<TemporalServiceClientWithMetrics>>);
+    impl AnyClient {
+        pub(crate) fn into_inner(self) -> Box<ConfiguredClient<TemporalServiceClientWithMetrics>> {
+            self.0
+        }
+    }
+
+    impl From<RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>> for AnyClient {
+        fn from(c: RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>) -> Self {
+            Self(Box::new(c.into_inner()))
+        }
+    }
+    impl From<RetryClient<Client>> for AnyClient {
+        fn from(c: RetryClient<Client>) -> Self {
+            Self(Box::new(c.into_inner().into_inner()))
+        }
+    }
+    impl From<Arc<RetryClient<Client>>> for AnyClient {
+        fn from(c: Arc<RetryClient<Client>>) -> Self {
+            Self(Box::new(c.get_client().inner().clone()))
+        }
+    }
+    impl From<ConfiguredClient<TemporalServiceClientWithMetrics>> for AnyClient {
+        fn from(c: ConfiguredClient<TemporalServiceClientWithMetrics>) -> Self {
+            Self(Box::new(c))
+        }
+    }
+}

package/sdk-core/core/src/pollers/poll_buffer.rs

@@ -1,6 +1,6 @@
 use crate::{
     pollers::{self, Poller},
-    worker::client::WorkerClientBag,
+    worker::client::WorkerClient,
 };
 use futures::{prelude::stream::FuturesUnordered, StreamExt};
 use std::{
@@ -199,7 +199,7 @@ impl Poller<PollWorkflowTaskQueueResponse> for WorkflowTaskPoller {
 
 pub type PollWorkflowTaskBuffer = LongPollBuffer<PollWorkflowTaskQueueResponse>;
 pub(crate) fn new_workflow_task_buffer(
-    client: Arc<WorkerClientBag>,
+    client: Arc<dyn WorkerClient>,
     task_queue: String,
     is_sticky: bool,
     concurrent_pollers: usize,
@@ -220,7 +220,7 @@ pub(crate) fn new_workflow_task_buffer(
 
 pub type PollActivityTaskBuffer = LongPollBuffer<PollActivityTaskQueueResponse>;
 pub(crate) fn new_activity_task_buffer(
-    client: Arc<WorkerClientBag>,
+    client: Arc<dyn WorkerClient>,
     task_queue: String,
     concurrent_pollers: usize,
     buffer_size: usize,
@@ -262,7 +262,7 @@ mod tests {
             });
 
         let pb = new_workflow_task_buffer(
-            Arc::new(mock_client.into()),
+            Arc::new(mock_client),
             "someq".to_string(),
             false,
             1,

package/sdk-core/core/src/replay/mod.rs

@@ -2,7 +2,7 @@
 //! to replay canned histories. It should be used by Lang SDKs to provide replay capabilities to
 //! users during testing.
 
-use crate::{worker::client::mocks::mock_manual_workflow_client, WorkerClientBag};
+use crate::worker::client::{mocks::mock_manual_workflow_client, WorkerClient};
 use futures::FutureExt;
 use std::{
     sync::{
@@ -29,7 +29,7 @@ pub use temporal_sdk_core_protos::{
 pub(crate) fn mock_client_from_history(
     history: &History,
     task_queue: impl Into<String>,
-) -> WorkerClientBag {
+) -> impl WorkerClient {
     let mut mg = mock_manual_workflow_client();
 
     let hist_info = HistoryInfo::new_from_history(history, None).unwrap();
@@ -67,5 +67,5 @@ pub(crate) fn mock_client_from_history(
         async move { Ok(RespondWorkflowTaskFailedResponse {}) }.boxed()
     });
 
-    WorkerClientBag::new(Box::new(mg), "fake_namespace".to_string())
+    mg
 }