temporalio 0.0.0 → 0.0.2

data/bridge/src/lib.rs

@@ -0,0 +1,239 @@
+#[macro_use]
+extern crate rutie;
+extern crate lazy_static;
+
+mod connection;
+mod runtime;
+mod worker;
+
+use connection::{Connection, RpcParams};
+use runtime::Runtime;
+use rutie::{
+    Module, Object, Symbol, RString, Encoding, AnyObject, AnyException, Exception, VM, Thread,
+    NilClass, Hash, Integer,
+};
+use std::collections::HashMap;
+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("Temporalio::Bridge::Error", Some(message)));
+}
+
+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)
+}
+
+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> {
+    let mut result = HashMap::new();
+
+    hash.each(|k, v| {
+        result.insert(
+            k.try_convert_to::<RString>().map_err(VM::raise_ex).unwrap().to_string(),
+            v.try_convert_to::<RString>().map_err(VM::raise_ex).unwrap().to_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);
+
+class!(TemporalBridge);
+
+methods!(
+    TemporalBridge,
+    _rtself, // somehow compiler is sure this is unused and insists on the "_"
+
+    fn create_connection(runtime: AnyObject, host: RString) -> AnyObject {
+        let host = host.map_err(VM::raise_ex).unwrap().to_string();
+        let runtime = runtime.unwrap();
+        let runtime = runtime.get_data(&*RUNTIME_WRAPPER);
+
+        let result = Thread::call_without_gvl(move || {
+            Connection::connect(runtime.tokio_runtime.clone(), host.clone())
+        }, Some(|| {}));
+
+        let connection = result.map_err(|e| raise_bridge_exception(&e.to_string())).unwrap();
+
+        Module::from_existing("Temporalio")
+            .get_nested_module("Bridge")
+            .get_nested_class("Connection")
+            .wrap_data(connection, &*CONNECTION_WRAPPER)
+    }
+
+    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 = 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(|| {
+            let connection = _rtself.get_data_mut(&*CONNECTION_WRAPPER);
+            let params = RpcParams {
+                rpc: rpc.clone(),
+                request: request.clone(),
+                metadata: metadata.clone(),
+                timeout_millis: timeout
+            };
+            connection.call(params, token.clone())
+        }, Some(|| { token.cancel() }));
+
+        let response = result.map_err(|e| raise_bridge_exception(&e.to_string())).unwrap();
+
+        wrap_bytes(response)
+    }
+
+    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();
+
+        let runtime = Runtime::new(RUNTIME_THREAD_COUNT, telemetry_options);
+
+        Module::from_existing("Temporalio")
+            .get_nested_module("Bridge")
+            .get_nested_class("Runtime")
+            .wrap_data(runtime, &*RUNTIME_WRAPPER)
+    }
+
+    fn run_callback_loop() -> NilClass {
+        let runtime = _rtself.get_data_mut(&*RUNTIME_WRAPPER);
+        runtime.run_callback_loop();
+
+        NilClass::new()
+    }
+
+    fn create_worker(runtime: AnyObject, connection: AnyObject, namespace: RString, task_queue: RString) -> AnyObject {
+        let namespace = namespace.map_err(VM::raise_ex).unwrap().to_string();
+        let task_queue = task_queue.map_err(VM::raise_ex).unwrap().to_string();
+        let runtime = runtime.unwrap();
+        let runtime = runtime.get_data(&*RUNTIME_WRAPPER);
+        let connection = connection.unwrap();
+        let connection = connection.get_data(&*CONNECTION_WRAPPER);
+        let worker = Worker::new(runtime, &connection.client, &namespace, &task_queue);
+
+        Module::from_existing("Temporalio")
+            .get_nested_module("Bridge")
+            .get_nested_class("Worker")
+            .wrap_data(worker.unwrap(), &*WORKER_WRAPPER)
+    }
+
+    fn worker_poll_activity_task() -> NilClass {
+        if !VM::is_block_given() {
+            panic!("Called #poll_activity_task without a block");
+        }
+
+        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.poll_activity_task(callback);
+
+        result.map_err(|e| raise_bridge_exception(&e.to_string())).unwrap();
+
+        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("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);
+        });
+
+        module.define_nested_class("Connection", None).define(|klass| {
+            klass.def_self("connect", create_connection);
+            klass.def("call", call_rpc);
+        });
+
+        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

@@ -0,0 +1,54 @@
+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>;
+
+pub enum Command {
+    RunCallback(Callback),
+    Shutdown,
+}
+
+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, telemetry_options: TelemetryOptions) -> Self {
+        let (tx, rx): (Sender<Command>, Receiver<Command>) = channel();
+        let tokio_runtime = Arc::new(
+            Builder::new_multi_thread()
+                .worker_threads(thread_count.into())
+                .enable_all()
+                .thread_name("core")
+                .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 { core_runtime, tokio_runtime, callback_tx: tx, callback_rx: rx }
+    }
+
+    // This function is expected to be called from a Ruby thread
+    pub fn run_callback_loop(&self) {
+        let unblock = || {
+            self.callback_tx.send(Command::Shutdown {}).expect("Unable to close callback loop");
+        };
+
+        while let Ok(msg) = Thread::call_without_gvl(|| self.callback_rx.recv(), Some(unblock)) {
+            match msg {
+                Command::RunCallback(callback) => callback(),
+                Command::Shutdown => break,
+            }
+        };
+    }
+}

data/bridge/src/worker.rs

@@ -0,0 +1,124 @@
+use crate::connection::Client;
+use crate::runtime::{Callback, Command, Runtime};
+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};
+
+#[derive(Error, Debug)]
+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>;
+
+pub struct Worker {
+    core_worker: Arc<temporal_sdk_core::Worker>,
+    tokio_runtime: Arc<TokioRuntime>,
+    callback_tx: Sender<Command>,
+}
+
+impl Worker {
+    // TODO: Extend this to include full worker config
+    pub fn new(runtime: &Runtime, client: &Client, namespace: &str, task_queue: &str) -> Result<Worker, WorkerError> {
+        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(&runtime.core_runtime, config, client.clone())
+        }).expect("Failed to initialize Core Worker");
+
+        Ok(Worker {
+            core_worker: Arc::new(core_worker),
+            tokio_runtime: runtime.tokio_runtime.clone(),
+            callback_tx: runtime.callback_tx.clone(),
+        })
+    }
+
+    pub fn poll_activity_task<F>(&self, callback: F) -> Result<(), WorkerError> where F: FnOnce(WorkerResult) + Send + 'static {
+        let core_worker = self.core_worker.clone();
+        let callback_tx = self.callback_tx.clone();
+
+        self.tokio_runtime.spawn(async move {
+            let result = core_worker.poll_activity_task().await;
+
+            let callback: Callback = match result {
+                Ok(task) => {
+                    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))))
+            };
+
+            callback_tx.send(Command::RunCallback(callback)).expect("Unable to send a callback");
+        });
+
+        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/ext/Rakefile

@@ -0,0 +1,9 @@
+require 'thermite/tasks'
+require_relative '../lib/thermite_patch'
+
+Thermite::Tasks.new(
+  cargo_project_path: File.expand_path('../bridge', __dir__),
+  ruby_project_path: File.expand_path('..', __dir__),
+)
+
+task default: 'thermite:build'

data/lib/gen/dependencies/gogoproto/gogo_pb.rb

@@ -0,0 +1,14 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: dependencies/gogoproto/gogo.proto
+
+require 'google/protobuf'
+
+require 'google/protobuf/descriptor_pb'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("dependencies/gogoproto/gogo.proto", :syntax => :proto2) do
+  end
+end
+
+module Gogoproto
+end

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

@@ -0,0 +1,50 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: temporal/api/batch/v1/message.proto
+
+require 'google/protobuf'
+
+require 'dependencies/gogoproto/gogo_pb'
+require 'google/protobuf/timestamp_pb'
+require 'temporal/api/common/v1/message_pb'
+require 'temporal/api/enums/v1/batch_operation_pb'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("temporal/api/batch/v1/message.proto", :syntax => :proto3) do
+    add_message "temporal.api.batch.v1.BatchOperationInfo" do
+      optional :job_id, :string, 1
+      optional :state, :enum, 2, "temporal.api.enums.v1.BatchOperationState"
+      optional :start_time, :message, 3, "google.protobuf.Timestamp"
+      optional :close_time, :message, 4, "google.protobuf.Timestamp"
+    end
+    add_message "temporal.api.batch.v1.BatchOperationTermination" do
+      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
+      optional :input, :message, 2, "temporal.api.common.v1.Payloads"
+      optional :header, :message, 3, "temporal.api.common.v1.Header"
+      optional :identity, :string, 4
+    end
+    add_message "temporal.api.batch.v1.BatchOperationCancellation" do
+      optional :identity, :string, 1
+    end
+    add_message "temporal.api.batch.v1.BatchOperationDeletion" do
+      optional :identity, :string, 1
+    end
+  end
+end
+
+module Temporalio
+  module Api
+    module Batch
+      module V1
+        BatchOperationInfo = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.batch.v1.BatchOperationInfo").msgclass
+        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
+end

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

@@ -0,0 +1,174 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: temporal/api/command/v1/message.proto
+
+require 'google/protobuf'
+
+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/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
+  add_file("temporal/api/command/v1/message.proto", :syntax => :proto3) do
+    add_message "temporal.api.command.v1.ScheduleActivityTaskCommandAttributes" do
+      optional :activity_id, :string, 1
+      optional :activity_type, :message, 2, "temporal.api.common.v1.ActivityType"
+      optional :task_queue, :message, 4, "temporal.api.taskqueue.v1.TaskQueue"
+      optional :header, :message, 5, "temporal.api.common.v1.Header"
+      optional :input, :message, 6, "temporal.api.common.v1.Payloads"
+      optional :schedule_to_close_timeout, :message, 7, "google.protobuf.Duration"
+      optional :schedule_to_start_timeout, :message, 8, "google.protobuf.Duration"
+      optional :start_to_close_timeout, :message, 9, "google.protobuf.Duration"
+      optional :heartbeat_timeout, :message, 10, "google.protobuf.Duration"
+      optional :retry_policy, :message, 11, "temporal.api.common.v1.RetryPolicy"
+      optional :request_eager_execution, :bool, 12
+    end
+    add_message "temporal.api.command.v1.RequestCancelActivityTaskCommandAttributes" do
+      optional :scheduled_event_id, :int64, 1
+    end
+    add_message "temporal.api.command.v1.StartTimerCommandAttributes" do
+      optional :timer_id, :string, 1
+      optional :start_to_fire_timeout, :message, 2, "google.protobuf.Duration"
+    end
+    add_message "temporal.api.command.v1.CompleteWorkflowExecutionCommandAttributes" do
+      optional :result, :message, 1, "temporal.api.common.v1.Payloads"
+    end
+    add_message "temporal.api.command.v1.FailWorkflowExecutionCommandAttributes" do
+      optional :failure, :message, 1, "temporal.api.failure.v1.Failure"
+    end
+    add_message "temporal.api.command.v1.CancelTimerCommandAttributes" do
+      optional :timer_id, :string, 1
+    end
+    add_message "temporal.api.command.v1.CancelWorkflowExecutionCommandAttributes" do
+      optional :details, :message, 1, "temporal.api.common.v1.Payloads"
+    end
+    add_message "temporal.api.command.v1.RequestCancelExternalWorkflowExecutionCommandAttributes" do
+      optional :namespace, :string, 1
+      optional :workflow_id, :string, 2
+      optional :run_id, :string, 3
+      optional :control, :string, 4
+      optional :child_workflow_only, :bool, 5
+      optional :reason, :string, 6
+    end
+    add_message "temporal.api.command.v1.SignalExternalWorkflowExecutionCommandAttributes" do
+      optional :namespace, :string, 1
+      optional :execution, :message, 2, "temporal.api.common.v1.WorkflowExecution"
+      optional :signal_name, :string, 3
+      optional :input, :message, 4, "temporal.api.common.v1.Payloads"
+      optional :control, :string, 5
+      optional :child_workflow_only, :bool, 6
+      optional :header, :message, 7, "temporal.api.common.v1.Header"
+    end
+    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"
+      optional :header, :message, 3, "temporal.api.common.v1.Header"
+      optional :failure, :message, 4, "temporal.api.failure.v1.Failure"
+    end
+    add_message "temporal.api.command.v1.ContinueAsNewWorkflowExecutionCommandAttributes" do
+      optional :workflow_type, :message, 1, "temporal.api.common.v1.WorkflowType"
+      optional :task_queue, :message, 2, "temporal.api.taskqueue.v1.TaskQueue"
+      optional :input, :message, 3, "temporal.api.common.v1.Payloads"
+      optional :workflow_run_timeout, :message, 4, "google.protobuf.Duration"
+      optional :workflow_task_timeout, :message, 5, "google.protobuf.Duration"
+      optional :backoff_start_interval, :message, 6, "google.protobuf.Duration"
+      optional :retry_policy, :message, 7, "temporal.api.common.v1.RetryPolicy"
+      optional :initiator, :enum, 8, "temporal.api.enums.v1.ContinueAsNewInitiator"
+      optional :failure, :message, 9, "temporal.api.failure.v1.Failure"
+      optional :last_completion_result, :message, 10, "temporal.api.common.v1.Payloads"
+      optional :cron_schedule, :string, 11
+      optional :header, :message, 12, "temporal.api.common.v1.Header"
+      optional :memo, :message, 13, "temporal.api.common.v1.Memo"
+      optional :search_attributes, :message, 14, "temporal.api.common.v1.SearchAttributes"
+    end
+    add_message "temporal.api.command.v1.StartChildWorkflowExecutionCommandAttributes" do
+      optional :namespace, :string, 1
+      optional :workflow_id, :string, 2
+      optional :workflow_type, :message, 3, "temporal.api.common.v1.WorkflowType"
+      optional :task_queue, :message, 4, "temporal.api.taskqueue.v1.TaskQueue"
+      optional :input, :message, 5, "temporal.api.common.v1.Payloads"
+      optional :workflow_execution_timeout, :message, 6, "google.protobuf.Duration"
+      optional :workflow_run_timeout, :message, 7, "google.protobuf.Duration"
+      optional :workflow_task_timeout, :message, 8, "google.protobuf.Duration"
+      optional :parent_close_policy, :enum, 9, "temporal.api.enums.v1.ParentClosePolicy"
+      optional :control, :string, 10
+      optional :workflow_id_reuse_policy, :enum, 11, "temporal.api.enums.v1.WorkflowIdReusePolicy"
+      optional :retry_policy, :message, 12, "temporal.api.common.v1.RetryPolicy"
+      optional :cron_schedule, :string, 13
+      optional :header, :message, 14, "temporal.api.common.v1.Header"
+      optional :memo, :message, 15, "temporal.api.common.v1.Memo"
+      optional :search_attributes, :message, 16, "temporal.api.common.v1.SearchAttributes"
+    end
+    add_message "temporal.api.command.v1.AcceptWorkflowUpdateCommandAttributes" do
+      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 :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"
+      oneof :attributes do
+        optional :schedule_activity_task_command_attributes, :message, 2, "temporal.api.command.v1.ScheduleActivityTaskCommandAttributes"
+        optional :start_timer_command_attributes, :message, 3, "temporal.api.command.v1.StartTimerCommandAttributes"
+        optional :complete_workflow_execution_command_attributes, :message, 4, "temporal.api.command.v1.CompleteWorkflowExecutionCommandAttributes"
+        optional :fail_workflow_execution_command_attributes, :message, 5, "temporal.api.command.v1.FailWorkflowExecutionCommandAttributes"
+        optional :request_cancel_activity_task_command_attributes, :message, 6, "temporal.api.command.v1.RequestCancelActivityTaskCommandAttributes"
+        optional :cancel_timer_command_attributes, :message, 7, "temporal.api.command.v1.CancelTimerCommandAttributes"
+        optional :cancel_workflow_execution_command_attributes, :message, 8, "temporal.api.command.v1.CancelWorkflowExecutionCommandAttributes"
+        optional :request_cancel_external_workflow_execution_command_attributes, :message, 9, "temporal.api.command.v1.RequestCancelExternalWorkflowExecutionCommandAttributes"
+        optional :record_marker_command_attributes, :message, 10, "temporal.api.command.v1.RecordMarkerCommandAttributes"
+        optional :continue_as_new_workflow_execution_command_attributes, :message, 11, "temporal.api.command.v1.ContinueAsNewWorkflowExecutionCommandAttributes"
+        optional :start_child_workflow_execution_command_attributes, :message, 12, "temporal.api.command.v1.StartChildWorkflowExecutionCommandAttributes"
+        optional :signal_external_workflow_execution_command_attributes, :message, 13, "temporal.api.command.v1.SignalExternalWorkflowExecutionCommandAttributes"
+        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 Temporalio
+  module Api
+    module Command
+      module V1
+        ScheduleActivityTaskCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.ScheduleActivityTaskCommandAttributes").msgclass
+        RequestCancelActivityTaskCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.RequestCancelActivityTaskCommandAttributes").msgclass
+        StartTimerCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.StartTimerCommandAttributes").msgclass
+        CompleteWorkflowExecutionCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.CompleteWorkflowExecutionCommandAttributes").msgclass
+        FailWorkflowExecutionCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.FailWorkflowExecutionCommandAttributes").msgclass
+        CancelTimerCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.CancelTimerCommandAttributes").msgclass
+        CancelWorkflowExecutionCommandAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.CancelWorkflowExecutionCommandAttributes").msgclass
+        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
+  end
+end