temporalio 0.0.1 → 0.0.2

data/bridge/src/connection.rs

@@ -8,7 +8,9 @@ use temporal_client::{
     ConfiguredClient, TemporalServiceClientWithMetrics
 };
 use thiserror::Error;
+use tokio::{select};
 use tokio::runtime::{Runtime};
+use tokio_util::sync::CancellationToken;
 use tonic::metadata::{MetadataKey,MetadataValue};
 use url::Url;
 
@@ -42,13 +44,18 @@ pub enum ConnectionError {
 
     #[error(transparent)]
     RequestError(#[from] tonic::Status),
+
+    #[error("RPC call was cancelled")]
+    RequestCancelled,
 }
 
+pub type RpcResult = Result<Vec<u8>, ConnectionError>;
+
 fn rpc_req<P: prost::Message + Default>(params: RpcParams) -> Result<tonic::Request<P>, ConnectionError> {
     let proto = P::decode(&*params.request)?;
     let mut req = tonic::Request::new(proto);
 
-    for (k, v) in params.metadata {
+    for (k, v) in &params.metadata {
         req.metadata_mut().insert(
             MetadataKey::from_str(k.as_str())?,
             MetadataValue::try_from(v.as_str())?
@@ -62,16 +69,77 @@ fn rpc_req<P: prost::Message + Default>(params: RpcParams) -> Result<tonic::Requ
     Ok(req)
 }
 
-fn rpc_resp<P: prost::Message + Default>(res: Result<tonic::Response<P>, tonic::Status>) -> Result<Vec<u8>, ConnectionError> {
+fn rpc_resp<P: prost::Message + Default>(res: Result<tonic::Response<P>, tonic::Status>) -> RpcResult {
     Ok(res?.get_ref().encode_to_vec())
 }
 
 macro_rules! rpc_call {
-    ($client:expr, $runtime:expr, $rpc:ident, $params:expr) => {
-        rpc_resp($runtime.block_on($client.$rpc(rpc_req($params)?)))
+    ($client:expr, $rpc:ident, $params:expr) => {
+        rpc_resp($client.$rpc(rpc_req($params)?).await)
     };
 }
 
+async fn make_rpc_call(mut client: Client, params: RpcParams) -> RpcResult {
+    match params.rpc.as_str() {
+        "register_namespace" => rpc_call!(client, register_namespace, params),
+        "describe_namespace" => rpc_call!(client, describe_namespace, params),
+        "list_namespaces" => rpc_call!(client, list_namespaces, params),
+        "update_namespace" => rpc_call!(client, update_namespace, params),
+        "deprecate_namespace" => rpc_call!(client, deprecate_namespace, params),
+        "start_workflow_execution" => rpc_call!(client, start_workflow_execution, params),
+        "get_workflow_execution_history" => rpc_call!(client, get_workflow_execution_history, params),
+        // "get_workflow_execution_history_reverse" => rpc_call!(client, get_workflow_execution_history_reverse, params),
+        "poll_workflow_task_queue" => rpc_call!(client, poll_workflow_task_queue, params),
+        "respond_workflow_task_completed" => rpc_call!(client, respond_workflow_task_completed, params),
+        "respond_workflow_task_failed" => rpc_call!(client, respond_workflow_task_failed, params),
+        "poll_activity_task_queue" => rpc_call!(client, poll_activity_task_queue, params),
+        "record_activity_task_heartbeat" => rpc_call!(client, record_activity_task_heartbeat, params),
+        "record_activity_task_heartbeat_by_id" => rpc_call!(client, record_activity_task_heartbeat_by_id, params),
+        "respond_activity_task_completed" => rpc_call!(client, respond_activity_task_completed, params),
+        "respond_activity_task_completed_by_id" => rpc_call!(client, respond_activity_task_completed_by_id, params),
+        "respond_activity_task_failed" => rpc_call!(client, respond_activity_task_failed, params),
+        "respond_activity_task_failed_by_id" => rpc_call!(client, respond_activity_task_failed_by_id, params),
+        "respond_activity_task_canceled" => rpc_call!(client, respond_activity_task_canceled, params),
+        "respond_activity_task_canceled_by_id" => rpc_call!(client, respond_activity_task_canceled_by_id, params),
+        "request_cancel_workflow_execution" => rpc_call!(client, request_cancel_workflow_execution, params),
+        "signal_workflow_execution" => rpc_call!(client, signal_workflow_execution, params),
+        "signal_with_start_workflow_execution" => rpc_call!(client, signal_with_start_workflow_execution, params),
+        "reset_workflow_execution" => rpc_call!(client, reset_workflow_execution, params),
+        "terminate_workflow_execution" => rpc_call!(client, terminate_workflow_execution, params),
+        "delete_workflow_execution" => rpc_call!(client, delete_workflow_execution, params),
+        "list_open_workflow_executions" => rpc_call!(client, list_open_workflow_executions, params),
+        "list_closed_workflow_executions" => rpc_call!(client, list_closed_workflow_executions, params),
+        "list_workflow_executions" => rpc_call!(client, list_workflow_executions, params),
+        "list_archived_workflow_executions" => rpc_call!(client, list_archived_workflow_executions, params),
+        "scan_workflow_executions" => rpc_call!(client, scan_workflow_executions, params),
+        "count_workflow_executions" => rpc_call!(client, count_workflow_executions, params),
+        "get_search_attributes" => rpc_call!(client, get_search_attributes, params),
+        "respond_query_task_completed" => rpc_call!(client, respond_query_task_completed, params),
+        "reset_sticky_task_queue" => rpc_call!(client, reset_sticky_task_queue, params),
+        "query_workflow" => rpc_call!(client, query_workflow, params),
+        "describe_workflow_execution" => rpc_call!(client, describe_workflow_execution, params),
+        "describe_task_queue" => rpc_call!(client, describe_task_queue, params),
+        "get_cluster_info" => rpc_call!(client, get_cluster_info, params),
+        "get_system_info" => rpc_call!(client, get_system_info, params),
+        "list_task_queue_partitions" => rpc_call!(client, list_task_queue_partitions, params),
+        "create_schedule" => rpc_call!(client, create_schedule, params),
+        "describe_schedule" => rpc_call!(client, describe_schedule, params),
+        "update_schedule" => rpc_call!(client, update_schedule, params),
+        "patch_schedule" => rpc_call!(client, patch_schedule, params),
+        "list_schedule_matching_times" => rpc_call!(client, list_schedule_matching_times, params),
+        "delete_schedule" => rpc_call!(client, delete_schedule, params),
+        "list_schedules" => rpc_call!(client, list_schedules, params),
+        "update_worker_build_id_ordering" => rpc_call!(client, update_worker_build_id_ordering, params),
+        "get_worker_build_id_ordering" => rpc_call!(client, get_worker_build_id_ordering, params),
+        "update_workflow" => rpc_call!(client, update_workflow, params),
+        "start_batch_operation" => rpc_call!(client, start_batch_operation, params),
+        "stop_batch_operation" => rpc_call!(client, stop_batch_operation, params),
+        "describe_batch_operation" => rpc_call!(client, describe_batch_operation, params),
+        "list_batch_operations" => rpc_call!(client, list_batch_operations, params),
+        _ => Err(ConnectionError::InvalidRpc(params.rpc.to_string()))
+    }
+}
+
 // A Connection is a Client wrapper for making RPC calls
 pub struct Connection {
     pub client: Client,
@@ -105,63 +173,14 @@ impl Connection {
         Ok(Connection { client, runtime })
     }
 
-    pub fn call(&mut self, params: RpcParams) -> Result<Vec<u8>, ConnectionError> {
-        match params.rpc.as_str() {
-            "register_namespace" => rpc_call!(self.client, self.runtime, register_namespace, params),
-            "describe_namespace" => rpc_call!(self.client, self.runtime, describe_namespace, params),
-            "list_namespaces" => rpc_call!(self.client, self.runtime, list_namespaces, params),
-            "update_namespace" => rpc_call!(self.client, self.runtime, update_namespace, params),
-            "deprecate_namespace" => rpc_call!(self.client, self.runtime, deprecate_namespace, params),
-            "start_workflow_execution" => rpc_call!(self.client, self.runtime, start_workflow_execution, params),
-            "get_workflow_execution_history" => rpc_call!(self.client, self.runtime, get_workflow_execution_history, params),
-            // "get_workflow_execution_history_reverse" => rpc_call!(self.client, self.runtime, get_workflow_execution_history_reverse, params),
-            "poll_workflow_task_queue" => rpc_call!(self.client, self.runtime, poll_workflow_task_queue, params),
-            "respond_workflow_task_completed" => rpc_call!(self.client, self.runtime, respond_workflow_task_completed, params),
-            "respond_workflow_task_failed" => rpc_call!(self.client, self.runtime, respond_workflow_task_failed, params),
-            "poll_activity_task_queue" => rpc_call!(self.client, self.runtime, poll_activity_task_queue, params),
-            "record_activity_task_heartbeat" => rpc_call!(self.client, self.runtime, record_activity_task_heartbeat, params),
-            "record_activity_task_heartbeat_by_id" => rpc_call!(self.client, self.runtime, record_activity_task_heartbeat_by_id, params),
-            "respond_activity_task_completed" => rpc_call!(self.client, self.runtime, respond_activity_task_completed, params),
-            "respond_activity_task_completed_by_id" => rpc_call!(self.client, self.runtime, respond_activity_task_completed_by_id, params),
-            "respond_activity_task_failed" => rpc_call!(self.client, self.runtime, respond_activity_task_failed, params),
-            "respond_activity_task_failed_by_id" => rpc_call!(self.client, self.runtime, respond_activity_task_failed_by_id, params),
-            "respond_activity_task_canceled" => rpc_call!(self.client, self.runtime, respond_activity_task_canceled, params),
-            "respond_activity_task_canceled_by_id" => rpc_call!(self.client, self.runtime, respond_activity_task_canceled_by_id, params),
-            "request_cancel_workflow_execution" => rpc_call!(self.client, self.runtime, request_cancel_workflow_execution, params),
-            "signal_workflow_execution" => rpc_call!(self.client, self.runtime, signal_workflow_execution, params),
-            "signal_with_start_workflow_execution" => rpc_call!(self.client, self.runtime, signal_with_start_workflow_execution, params),
-            "reset_workflow_execution" => rpc_call!(self.client, self.runtime, reset_workflow_execution, params),
-            "terminate_workflow_execution" => rpc_call!(self.client, self.runtime, terminate_workflow_execution, params),
-            "list_open_workflow_executions" => rpc_call!(self.client, self.runtime, list_open_workflow_executions, params),
-            "list_closed_workflow_executions" => rpc_call!(self.client, self.runtime, list_closed_workflow_executions, params),
-            "list_workflow_executions" => rpc_call!(self.client, self.runtime, list_workflow_executions, params),
-            "list_archived_workflow_executions" => rpc_call!(self.client, self.runtime, list_archived_workflow_executions, params),
-            "scan_workflow_executions" => rpc_call!(self.client, self.runtime, scan_workflow_executions, params),
-            "count_workflow_executions" => rpc_call!(self.client, self.runtime, count_workflow_executions, params),
-            "get_search_attributes" => rpc_call!(self.client, self.runtime, get_search_attributes, params),
-            "respond_query_task_completed" => rpc_call!(self.client, self.runtime, respond_query_task_completed, params),
-            "reset_sticky_task_queue" => rpc_call!(self.client, self.runtime, reset_sticky_task_queue, params),
-            "query_workflow" => rpc_call!(self.client, self.runtime, query_workflow, params),
-            "describe_workflow_execution" => rpc_call!(self.client, self.runtime, describe_workflow_execution, params),
-            "describe_task_queue" => rpc_call!(self.client, self.runtime, describe_task_queue, params),
-            "get_cluster_info" => rpc_call!(self.client, self.runtime, get_cluster_info, params),
-            "get_system_info" => rpc_call!(self.client, self.runtime, get_system_info, params),
-            "list_task_queue_partitions" => rpc_call!(self.client, self.runtime, list_task_queue_partitions, params),
-            "create_schedule" => rpc_call!(self.client, self.runtime, create_schedule, params),
-            "describe_schedule" => rpc_call!(self.client, self.runtime, describe_schedule, params),
-            "update_schedule" => rpc_call!(self.client, self.runtime, update_schedule, params),
-            "patch_schedule" => rpc_call!(self.client, self.runtime, patch_schedule, params),
-            "list_schedule_matching_times" => rpc_call!(self.client, self.runtime, list_schedule_matching_times, params),
-            "delete_schedule" => rpc_call!(self.client, self.runtime, delete_schedule, params),
-            "list_schedules" => rpc_call!(self.client, self.runtime, list_schedules, params),
-            "update_worker_build_id_ordering" => rpc_call!(self.client, self.runtime, update_worker_build_id_ordering, params),
-            "get_worker_build_id_ordering" => rpc_call!(self.client, self.runtime, get_worker_build_id_ordering, params),
-            "update_workflow" => rpc_call!(self.client, self.runtime, update_workflow, params),
-            "start_batch_operation" => rpc_call!(self.client, self.runtime, start_batch_operation, params),
-            "stop_batch_operation" => rpc_call!(self.client, self.runtime, stop_batch_operation, params),
-            "describe_batch_operation" => rpc_call!(self.client, self.runtime, describe_batch_operation, params),
-            "list_batch_operations" => rpc_call!(self.client, self.runtime, list_batch_operations, params),
-            _ => Err(ConnectionError::InvalidRpc(params.rpc.to_string()))
-        }
+    pub fn call(&self, params: RpcParams, cancel_token: CancellationToken) -> RpcResult {
+        let core_client = self.client.clone();
+
+        self.runtime.block_on(async move {
+            select! {
+                _ = cancel_token.cancelled() => Err(ConnectionError::RequestCancelled),
+                result = make_rpc_call(core_client, params) => result
+            }
+        })
     }
 }

data/bridge/src/lib.rs

@@ -13,18 +13,34 @@ use rutie::{
     NilClass, Hash, Integer,
 };
 use std::collections::HashMap;
-use temporal_sdk_core::{Logger, TelemetryOptionsBuilder};
-use worker::{Worker, WorkerResult};
+use temporal_sdk_core_api::telemetry::{Logger, TelemetryOptionsBuilder};
+use tokio_util::sync::CancellationToken;
+use worker::{Worker, WorkerError, WorkerResult};
 
 const RUNTIME_THREAD_COUNT: u8 = 2;
 
 fn raise_bridge_exception(message: &str) {
-    VM::raise_ex(AnyException::new("Temporal::Bridge::Error", Some(message)));
+    VM::raise_ex(AnyException::new("Temporalio::Bridge::Error", Some(message)));
 }
 
-fn wrap_bytes(bytes: &[u8]) -> AnyObject {
+fn wrap_worker_error(e: &WorkerError) -> AnyException {
+    let name = match e {
+        WorkerError::Shutdown() => "Temporalio::Bridge::Error::WorkerShutdown",
+        _ => "Temporalio::Bridge::Error"
+    };
+
+    AnyException::new(name, Some(&format!("[{:?}] {}", e, e)))
+}
+
+fn wrap_bytes(bytes: Vec<u8>) -> RString {
     let enc = Encoding::find("ASCII-8BIT").unwrap();
-    RString::from_bytes(bytes, &enc).to_any_object()
+    RString::from_bytes(&bytes, &enc)
+}
+
+fn unwrap_bytes(string: RString) -> Vec<u8> {
+    // It is important to use the _unchecked conversion, otherwise Rutie
+    // will assume incorrect encoding and screw up the encoded proto
+    string.to_vec_u8_unchecked()
 }
 
 fn to_hash_map(hash: Hash) -> HashMap<String, String> {
@@ -40,6 +56,14 @@ fn to_hash_map(hash: Hash) -> HashMap<String, String> {
     result
 }
 
+fn worker_result_to_proc_args(result: WorkerResult) -> [AnyObject; 2] {
+    let ruby_nil = NilClass::new().to_any_object();
+    match result {
+        Ok(bytes) => [wrap_bytes(bytes).to_any_object(), ruby_nil],
+        Err(e) => [ruby_nil, wrap_worker_error(&e).to_any_object()]
+    }
+}
+
 wrappable_struct!(Connection, ConnectionWrapper, CONNECTION_WRAPPER);
 wrappable_struct!(Runtime, RuntimeWrapper, RUNTIME_WRAPPER);
 wrappable_struct!(Worker, WorkerWrapper, WORKER_WRAPPER);
@@ -61,7 +85,7 @@ methods!(
 
         let connection = result.map_err(|e| raise_bridge_exception(&e.to_string())).unwrap();
 
-        Module::from_existing("Temporal")
+        Module::from_existing("Temporalio")
             .get_nested_module("Bridge")
             .get_nested_class("Connection")
             .wrap_data(connection, &*CONNECTION_WRAPPER)
@@ -69,11 +93,12 @@ methods!(
 
     fn call_rpc(rpc: Symbol, request: RString, metadata: Hash, timeout: Integer) -> RString {
         let rpc = rpc.map_err(VM::raise_ex).unwrap().to_string();
-        let request = request.map_err(VM::raise_ex).unwrap().to_string().as_bytes().to_vec();
+        let request = unwrap_bytes(request.map_err(VM::raise_ex).unwrap());
         let metadata = to_hash_map(metadata.map_err(VM::raise_ex).unwrap());
         let timeout = timeout.map_or(None, |v| Some(v.to_u64()));
+        let token = CancellationToken::new();
 
-        let result = Thread::call_without_gvl(move || {
+        let result = Thread::call_without_gvl(|| {
             let connection = _rtself.get_data_mut(&*CONNECTION_WRAPPER);
             let params = RpcParams {
                 rpc: rpc.clone(),
@@ -81,34 +106,24 @@ methods!(
                 metadata: metadata.clone(),
                 timeout_millis: timeout
             };
-            connection.call(params)
-        }, Some(|| {}));
+            connection.call(params, token.clone())
+        }, Some(|| { token.cancel() }));
 
         let response = result.map_err(|e| raise_bridge_exception(&e.to_string())).unwrap();
 
-        let enc = Encoding::find("ASCII-8BIT").unwrap();
-        RString::from_bytes(&response, &enc)
+        wrap_bytes(response)
     }
 
-    // TODO: Add telemetry configuration to this interface
-    fn init_telemetry() -> NilClass {
-        let telemetry_config = TelemetryOptionsBuilder::default()
-            .tracing_filter("temporal_sdk_core=DEBUG".to_string())
-            .logging(Logger::Console)
+    fn init_runtime() -> AnyObject {
+        let telemetry_options = TelemetryOptionsBuilder::default()
+            .logging(Logger::Console { filter: "temporal_sdk_core=DEBUG".to_string() })
             .build()
             .map_err(|e| raise_bridge_exception(&e.to_string()))
             .unwrap();
 
-        temporal_sdk_core::telemetry_init(&telemetry_config)
-            .expect("Unable to initialize telemetry");
+        let runtime = Runtime::new(RUNTIME_THREAD_COUNT, telemetry_options);
 
-        NilClass::new()
-    }
-
-    fn init_runtime() -> AnyObject {
-        let runtime = Runtime::new(RUNTIME_THREAD_COUNT);
-
-        Module::from_existing("Temporal")
+        Module::from_existing("Temporalio")
             .get_nested_module("Bridge")
             .get_nested_class("Runtime")
             .wrap_data(runtime, &*RUNTIME_WRAPPER)
@@ -130,7 +145,7 @@ methods!(
         let connection = connection.get_data(&*CONNECTION_WRAPPER);
         let worker = Worker::new(runtime, &connection.client, &namespace, &task_queue);
 
-        Module::from_existing("Temporal")
+        Module::from_existing("Temporalio")
             .get_nested_module("Bridge")
             .get_nested_class("Worker")
             .wrap_data(worker.unwrap(), &*WORKER_WRAPPER)
@@ -142,10 +157,8 @@ methods!(
         }
 
         let ruby_callback = VM::block_proc();
-
         let callback = move |result: WorkerResult| {
-            let bytes = result.map_err(|e| raise_bridge_exception(&e.to_string())).unwrap();
-            ruby_callback.call(&[wrap_bytes(&bytes)]);
+            ruby_callback.call(&worker_result_to_proc_args(result));
         };
 
         let worker = _rtself.get_data_mut(&*WORKER_WRAPPER);
@@ -155,13 +168,55 @@ methods!(
 
         NilClass::new()
     }
+
+    fn worker_complete_activity_task(proto: RString) -> NilClass {
+        if !VM::is_block_given() {
+            panic!("Called #worker_complete_activity_task without a block");
+        }
+
+        let bytes = unwrap_bytes(proto.map_err(VM::raise_ex).unwrap());
+        let ruby_callback = VM::block_proc();
+        let callback = move |result: WorkerResult| {
+            ruby_callback.call(&worker_result_to_proc_args(result));
+        };
+
+        let worker = _rtself.get_data_mut(&*WORKER_WRAPPER);
+        let result = worker.complete_activity_task(bytes, callback);
+
+        result.map_err(|e| raise_bridge_exception(&e.to_string())).unwrap();
+
+        NilClass::new()
+    }
+
+    fn worker_record_activity_heartbeat(proto: RString) -> NilClass {
+        let bytes = unwrap_bytes(proto.map_err(VM::raise_ex).unwrap());
+        let worker = _rtself.get_data_mut(&*WORKER_WRAPPER);
+
+        let result = worker.record_activity_heartbeat(bytes);
+
+        result.map_err(|e| raise_bridge_exception(&e.to_string())).unwrap();
+
+        NilClass::new()
+    }
+
+    fn worker_initiate_shutdown() -> NilClass {
+        let worker = _rtself.get_data_mut(&*WORKER_WRAPPER);
+        worker.initiate_shutdown();
+
+        NilClass::new()
+    }
+
+    fn worker_shutdown() -> NilClass {
+        let worker = _rtself.get_data_mut(&*WORKER_WRAPPER);
+        worker.shutdown();
+
+        NilClass::new()
+    }
 );
 
 #[no_mangle]
 pub extern "C" fn init_bridge() {
-    Module::from_existing("Temporal").get_nested_module("Bridge").define(|module| {
-        module.def_self("init_telemetry", init_telemetry);
-
+    Module::from_existing("Temporalio").get_nested_module("Bridge").define(|module| {
         module.define_nested_class("Runtime", None).define(|klass| {
             klass.def_self("init", init_runtime);
             klass.def("run_callback_loop", run_callback_loop);
@@ -175,6 +230,10 @@ pub extern "C" fn init_bridge() {
         module.define_nested_class("Worker", None).define(|klass| {
             klass.def_self("create", create_worker);
             klass.def("poll_activity_task", worker_poll_activity_task);
+            klass.def("complete_activity_task", worker_complete_activity_task);
+            klass.def("record_activity_heartbeat", worker_record_activity_heartbeat);
+            klass.def("initiate_shutdown", worker_initiate_shutdown);
+            klass.def("shutdown", worker_shutdown);
         });
     });
 }

data/bridge/src/runtime.rs

@@ -1,6 +1,8 @@
 use rutie::Thread;
 use std::sync::Arc;
 use std::sync::mpsc::{channel, Sender, Receiver};
+use temporal_sdk_core::CoreRuntime;
+use temporal_sdk_core_api::telemetry::TelemetryOptions;
 use tokio::runtime::{Builder, Runtime as TokioRuntime};
 
 pub type Callback = Box<dyn FnOnce() + Send + 'static>;
@@ -11,13 +13,14 @@ pub enum Command {
 }
 
 pub struct Runtime {
+    pub core_runtime: Arc<CoreRuntime>,
     pub tokio_runtime: Arc<TokioRuntime>,
     pub callback_tx: Sender<Command>,
     callback_rx: Receiver<Command>,
 }
 
 impl Runtime {
-    pub fn new(thread_count: u8) -> Self {
+    pub fn new(thread_count: u8, telemetry_options: TelemetryOptions) -> Self {
         let (tx, rx): (Sender<Command>, Receiver<Command>) = channel();
         let tokio_runtime = Arc::new(
             Builder::new_multi_thread()
@@ -27,8 +30,12 @@ impl Runtime {
                 .build()
                 .expect("Unable to start a runtime")
         );
+        let core_runtime = Arc::new(
+            CoreRuntime::new(telemetry_options, Builder::new_multi_thread())
+                .expect("Failed to initialize Core telemetry")
+        );
 
-        Runtime { tokio_runtime, callback_tx: tx, callback_rx: rx }
+        Runtime { core_runtime, tokio_runtime, callback_tx: tx, callback_rx: rx }
     }
 
     // This function is expected to be called from a Ruby thread

data/bridge/src/worker.rs

@@ -4,7 +4,9 @@ use prost::Message;
 use std::sync::Arc;
 use std::sync::mpsc::Sender;
 use temporal_sdk_core::api::{Worker as WorkerTrait};
+use temporal_sdk_core_api::errors::{PollActivityError};
 use temporal_sdk_core_api::worker::{WorkerConfigBuilder, WorkerConfigBuilderError};
+use temporal_sdk_core_protos::coresdk::{ActivityHeartbeat, ActivityTaskCompletion};
 use thiserror::Error;
 use tokio::runtime::{Runtime as TokioRuntime};
 
@@ -13,14 +15,23 @@ pub enum WorkerError {
     #[error(transparent)]
     EncodeError(#[from] prost::EncodeError),
 
+    #[error(transparent)]
+    DecodeError(#[from] prost::DecodeError),
+
     #[error(transparent)]
     InvalidWorkerOptions(#[from] WorkerConfigBuilderError),
 
     #[error(transparent)]
     UnableToPollActivityTask(#[from] temporal_sdk_core::api::errors::PollActivityError),
 
+    #[error(transparent)]
+    UnableToCompleteActivityTask(#[from] temporal_sdk_core::api::errors::CompleteActivityError),
+
     #[error("Unable to send a request. Channel is closed")]
     ChannelClosed(),
+
+    #[error("Core worker is shutting down")]
+    Shutdown(),
 }
 
 pub type WorkerResult = Result<Vec<u8>, WorkerError>;
@@ -37,11 +48,12 @@ impl Worker {
         let config = WorkerConfigBuilder::default()
             .namespace(namespace)
             .task_queue(task_queue)
+            .worker_build_id("test-worker-build") // TODO: replace this with an actual build id
             .build()?;
 
         let core_worker = runtime.tokio_runtime.block_on(async move {
-            temporal_sdk_core::init_worker(config, client.clone())
-        });
+            temporal_sdk_core::init_worker(&runtime.core_runtime, config, client.clone())
+        }).expect("Failed to initialize Core Worker");
 
         Ok(Worker {
             core_worker: Arc::new(core_worker),
@@ -62,6 +74,7 @@ impl Worker {
                     let bytes = task.encode_to_vec();
                     Box::new(move || callback(Ok(bytes)))
                 },
+                Err(PollActivityError::ShutDown) => Box::new(move || callback(Err(WorkerError::Shutdown()))),
                 Err(e) => Box::new(move || callback(Err(WorkerError::UnableToPollActivityTask(e))))
             };
 
@@ -70,4 +83,42 @@ impl Worker {
 
         Ok(())
     }
+
+    pub fn complete_activity_task<F>(&self, bytes: Vec<u8>, callback: F) -> Result<(), WorkerError> where F: FnOnce(WorkerResult) + Send + 'static {
+        let core_worker = self.core_worker.clone();
+        let callback_tx = self.callback_tx.clone();
+        let proto = ActivityTaskCompletion::decode(&*bytes)?;
+
+        self.tokio_runtime.spawn(async move {
+            let result = core_worker.complete_activity_task(proto).await;
+
+            let callback: Callback = match result {
+                Ok(()) => Box::new(move || callback(Ok(vec!()))),
+                Err(e) => Box::new(move || callback(Err(WorkerError::UnableToCompleteActivityTask(e))))
+            };
+
+            callback_tx.send(Command::RunCallback(callback)).expect("Unable to send a callback");
+        });
+
+        Ok(())
+    }
+
+    pub fn record_activity_heartbeat(&self, bytes: Vec<u8>) -> Result<(), WorkerError> {
+        let proto = ActivityHeartbeat::decode(&*bytes)?;
+        self.core_worker.record_activity_heartbeat(proto);
+
+        Ok(())
+    }
+
+    pub fn initiate_shutdown(&self) {
+        self.core_worker.initiate_shutdown();
+    }
+
+    pub fn shutdown(&self) {
+        let core_worker = self.core_worker.clone();
+
+        self.tokio_runtime.block_on(async move {
+            core_worker.shutdown().await;
+        });
+    }
 }

data/lib/gen/temporal/api/batch/v1/message_pb.rb

@@ -17,9 +17,8 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :close_time, :message, 4, "google.protobuf.Timestamp"
     end
     add_message "temporal.api.batch.v1.BatchOperationTermination" do
-      optional :reason, :string, 1
-      optional :details, :message, 2, "temporal.api.common.v1.Payloads"
-      optional :identity, :string, 3
+      optional :details, :message, 1, "temporal.api.common.v1.Payloads"
+      optional :identity, :string, 2
     end
     add_message "temporal.api.batch.v1.BatchOperationSignal" do
       optional :signal, :string, 1
@@ -28,13 +27,15 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :identity, :string, 4
     end
     add_message "temporal.api.batch.v1.BatchOperationCancellation" do
-      optional :reason, :string, 1
-      optional :identity, :string, 2
+      optional :identity, :string, 1
+    end
+    add_message "temporal.api.batch.v1.BatchOperationDeletion" do
+      optional :identity, :string, 1
     end
   end
 end
 
-module Temporal
+module Temporalio
   module Api
     module Batch
       module V1
@@ -42,6 +43,7 @@ module Temporal
         BatchOperationTermination = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.batch.v1.BatchOperationTermination").msgclass
         BatchOperationSignal = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.batch.v1.BatchOperationSignal").msgclass
         BatchOperationCancellation = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.batch.v1.BatchOperationCancellation").msgclass
+        BatchOperationDeletion = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.batch.v1.BatchOperationDeletion").msgclass
       end
     end
   end

data/lib/gen/temporal/api/command/v1/message_pb.rb

@@ -7,9 +7,9 @@ require 'google/protobuf/duration_pb'
 require 'dependencies/gogoproto/gogo_pb'
 require 'temporal/api/enums/v1/workflow_pb'
 require 'temporal/api/enums/v1/command_type_pb'
-require 'temporal/api/enums/v1/update_pb'
 require 'temporal/api/common/v1/message_pb'
 require 'temporal/api/failure/v1/message_pb'
+require 'temporal/api/interaction/v1/message_pb'
 require 'temporal/api/taskqueue/v1/message_pb'
 
 Google::Protobuf::DescriptorPool.generated_pool.build do
@@ -66,6 +66,9 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     add_message "temporal.api.command.v1.UpsertWorkflowSearchAttributesCommandAttributes" do
       optional :search_attributes, :message, 1, "temporal.api.common.v1.SearchAttributes"
     end
+    add_message "temporal.api.command.v1.ModifyWorkflowPropertiesCommandAttributes" do
+      optional :upserted_memo, :message, 1, "temporal.api.common.v1.Memo"
+    end
     add_message "temporal.api.command.v1.RecordMarkerCommandAttributes" do
       optional :marker_name, :string, 1
       map :details, :string, :message, 2, "temporal.api.common.v1.Payloads"
@@ -107,15 +110,16 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :search_attributes, :message, 16, "temporal.api.common.v1.SearchAttributes"
     end
     add_message "temporal.api.command.v1.AcceptWorkflowUpdateCommandAttributes" do
-      optional :update_id, :string, 1
+      optional :meta, :message, 1, "temporal.api.interaction.v1.Meta"
+      optional :input, :message, 2, "temporal.api.interaction.v1.Input"
     end
     add_message "temporal.api.command.v1.CompleteWorkflowUpdateCommandAttributes" do
-      optional :update_id, :string, 1
-      optional :durability_preference, :enum, 2, "temporal.api.enums.v1.WorkflowUpdateDurabilityPreference"
-      oneof :result do
-        optional :success, :message, 3, "temporal.api.common.v1.Payloads"
-        optional :failure, :message, 4, "temporal.api.failure.v1.Failure"
-      end
+      optional :meta, :message, 1, "temporal.api.interaction.v1.Meta"
+      optional :output, :message, 2, "temporal.api.interaction.v1.Output"
+    end
+    add_message "temporal.api.command.v1.RejectWorkflowUpdateCommandAttributes" do
+      optional :meta, :message, 1, "temporal.api.interaction.v1.Meta"
+      optional :failure, :message, 2, "temporal.api.failure.v1.Failure"
     end
     add_message "temporal.api.command.v1.Command" do
       optional :command_type, :enum, 1, "temporal.api.enums.v1.CommandType"
@@ -135,12 +139,14 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
         optional :upsert_workflow_search_attributes_command_attributes, :message, 14, "temporal.api.command.v1.UpsertWorkflowSearchAttributesCommandAttributes"
         optional :accept_workflow_update_command_attributes, :message, 15, "temporal.api.command.v1.AcceptWorkflowUpdateCommandAttributes"
         optional :complete_workflow_update_command_attributes, :message, 16, "temporal.api.command.v1.CompleteWorkflowUpdateCommandAttributes"
+        optional :modify_workflow_properties_command_attributes, :message, 17, "temporal.api.command.v1.ModifyWorkflowPropertiesCommandAttributes"
+        optional :reject_workflow_update_command_attributes, :message, 18, "temporal.api.command.v1.RejectWorkflowUpdateCommandAttributes"
       end
     end
   end
 end
 
-module Temporal
+module Temporalio
   module Api
     module Command
       module V1
@@ -154,11 +160,13 @@ module Temporal
         RequestCancelExternalWorkflowExecutionCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.RequestCancelExternalWorkflowExecutionCommandAttributes").msgclass
         SignalExternalWorkflowExecutionCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.SignalExternalWorkflowExecutionCommandAttributes").msgclass
         UpsertWorkflowSearchAttributesCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.UpsertWorkflowSearchAttributesCommandAttributes").msgclass
+        ModifyWorkflowPropertiesCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.ModifyWorkflowPropertiesCommandAttributes").msgclass
         RecordMarkerCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.RecordMarkerCommandAttributes").msgclass
         ContinueAsNewWorkflowExecutionCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.ContinueAsNewWorkflowExecutionCommandAttributes").msgclass
         StartChildWorkflowExecutionCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.StartChildWorkflowExecutionCommandAttributes").msgclass
         AcceptWorkflowUpdateCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.AcceptWorkflowUpdateCommandAttributes").msgclass
         CompleteWorkflowUpdateCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.CompleteWorkflowUpdateCommandAttributes").msgclass
+        RejectWorkflowUpdateCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.RejectWorkflowUpdateCommandAttributes").msgclass
         Command = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.Command").msgclass
       end
     end