temporalio 0.0.1

data/bridge/src/lib.rs

@@ -0,0 +1,180 @@
+#[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::{Logger, TelemetryOptionsBuilder};
+use worker::{Worker, WorkerResult};
+
+const RUNTIME_THREAD_COUNT: u8 = 2;
+
+fn raise_bridge_exception(message: &str) {
+    VM::raise_ex(AnyException::new("Temporal::Bridge::Error", Some(message)));
+}
+
+fn wrap_bytes(bytes: &[u8]) -> AnyObject {
+    let enc = Encoding::find("ASCII-8BIT").unwrap();
+    RString::from_bytes(bytes, &enc).to_any_object()
+}
+
+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
+}
+
+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("Temporal")
+            .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 = request.map_err(VM::raise_ex).unwrap().to_string().as_bytes().to_vec();
+        let metadata = to_hash_map(metadata.map_err(VM::raise_ex).unwrap());
+        let timeout = timeout.map_or(None, |v| Some(v.to_u64()));
+
+        let result = Thread::call_without_gvl(move || {
+            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)
+        }, Some(|| {}));
+
+        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)
+    }
+
+    // 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)
+            .build()
+            .map_err(|e| raise_bridge_exception(&e.to_string()))
+            .unwrap();
+
+        temporal_sdk_core::telemetry_init(&telemetry_config)
+            .expect("Unable to initialize telemetry");
+
+        NilClass::new()
+    }
+
+    fn init_runtime() -> AnyObject {
+        let runtime = Runtime::new(RUNTIME_THREAD_COUNT);
+
+        Module::from_existing("Temporal")
+            .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("Temporal")
+            .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| {
+            let bytes = result.map_err(|e| raise_bridge_exception(&e.to_string())).unwrap();
+            ruby_callback.call(&[wrap_bytes(&bytes)]);
+        };
+
+        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()
+    }
+);
+
+#[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.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);
+        });
+    });
+}

data/bridge/src/runtime.rs

@@ -0,0 +1,47 @@
+use rutie::Thread;
+use std::sync::Arc;
+use std::sync::mpsc::{channel, Sender, Receiver};
+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 tokio_runtime: Arc<TokioRuntime>,
+    pub callback_tx: Sender<Command>,
+    callback_rx: Receiver<Command>,
+}
+
+impl Runtime {
+    pub fn new(thread_count: u8) -> 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")
+        );
+
+        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,73 @@
+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::worker::{WorkerConfigBuilder, WorkerConfigBuilderError};
+use thiserror::Error;
+use tokio::runtime::{Runtime as TokioRuntime};
+
+#[derive(Error, Debug)]
+pub enum WorkerError {
+    #[error(transparent)]
+    EncodeError(#[from] prost::EncodeError),
+
+    #[error(transparent)]
+    InvalidWorkerOptions(#[from] WorkerConfigBuilderError),
+
+    #[error(transparent)]
+    UnableToPollActivityTask(#[from] temporal_sdk_core::api::errors::PollActivityError),
+
+    #[error("Unable to send a request. Channel is closed")]
+    ChannelClosed(),
+}
+
+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)
+            .build()?;
+
+        let core_worker = runtime.tokio_runtime.block_on(async move {
+            temporal_sdk_core::init_worker(config, client.clone())
+        });
+
+        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(e) => Box::new(move || callback(Err(WorkerError::UnableToPollActivityTask(e))))
+            };
+
+            callback_tx.send(Command::RunCallback(callback)).expect("Unable to send a callback");
+        });
+
+        Ok(())
+    }
+}

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,48 @@
+# 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 :reason, :string, 1
+      optional :details, :message, 2, "temporal.api.common.v1.Payloads"
+      optional :identity, :string, 3
+    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 :reason, :string, 1
+      optional :identity, :string, 2
+    end
+  end
+end
+
+module Temporal
+  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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: temporal/api/cluster/v1/message.proto
+
+require 'google/protobuf'
+
+require 'dependencies/gogoproto/gogo_pb'
+require 'google/protobuf/timestamp_pb'
+require 'temporal/api/enums/v1/cluster_pb'
+require 'temporal/api/enums/v1/common_pb'
+require 'temporal/api/version/v1/message_pb'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("temporal/api/cluster/v1/message.proto", :syntax => :proto3) do
+    add_message "temporal.api.cluster.v1.ClusterMetadata" do
+      optional :cluster, :string, 1
+      optional :history_shard_count, :int32, 2
+      optional :cluster_id, :string, 3
+      optional :version_info, :message, 4, "temporal.api.version.v1.VersionInfo"
+      map :index_search_attributes, :string, :message, 5, "temporal.api.cluster.v1.IndexSearchAttributes"
+      optional :cluster_address, :string, 6
+      optional :failover_version_increment, :int64, 7
+      optional :initial_failover_version, :int64, 8
+      optional :is_global_namespace_enabled, :bool, 9
+      optional :is_connection_enabled, :bool, 10
+    end
+    add_message "temporal.api.cluster.v1.IndexSearchAttributes" do
+      map :custom_search_attributes, :string, :enum, 1, "temporal.api.enums.v1.IndexedValueType"
+    end
+    add_message "temporal.api.cluster.v1.HostInfo" do
+      optional :identity, :string, 1
+    end
+    add_message "temporal.api.cluster.v1.RingInfo" do
+      optional :role, :string, 1
+      optional :member_count, :int32, 2
+      repeated :members, :message, 3, "temporal.api.cluster.v1.HostInfo"
+    end
+    add_message "temporal.api.cluster.v1.MembershipInfo" do
+      optional :current_host, :message, 1, "temporal.api.cluster.v1.HostInfo"
+      repeated :reachable_members, :string, 2
+      repeated :rings, :message, 3, "temporal.api.cluster.v1.RingInfo"
+    end
+    add_message "temporal.api.cluster.v1.ClusterMember" do
+      optional :role, :enum, 1, "temporal.api.enums.v1.ClusterMemberRole"
+      optional :host_id, :string, 2
+      optional :rpc_address, :string, 3
+      optional :rpc_port, :int32, 4
+      optional :session_start_time, :message, 5, "google.protobuf.Timestamp"
+      optional :last_heartbit_time, :message, 6, "google.protobuf.Timestamp"
+      optional :record_expiry_time, :message, 7, "google.protobuf.Timestamp"
+    end
+  end
+end
+
+module Temporal
+  module Api
+    module Cluster
+      module V1
+        ClusterMetadata = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.cluster.v1.ClusterMetadata").msgclass
+        IndexSearchAttributes = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.cluster.v1.IndexSearchAttributes").msgclass
+        HostInfo = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.cluster.v1.HostInfo").msgclass
+        RingInfo = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.cluster.v1.RingInfo").msgclass
+        MembershipInfo = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.cluster.v1.MembershipInfo").msgclass
+        ClusterMember = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.cluster.v1.ClusterMember").msgclass
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+# 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/enums/v1/update_pb'
+require 'temporal/api/common/v1/message_pb'
+require 'temporal/api/failure/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.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 :update_id, :string, 1
+    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
+    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"
+      end
+    end
+  end
+end
+
+module Temporal
+  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
+        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
+        Command = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("temporal.api.command.v1.Command").msgclass
+      end
+    end
+  end
+end