Merge upstream

README.md

@@ -1,12 +1,12 @@
-# Ruby worker for Temporal
+# Ruby SDK for Temporal
 
 [![Coverage Status](https://coveralls.io/repos/github/coinbase/temporal-ruby/badge.svg?branch=master)](https://coveralls.io/github/coinbase/temporal-ruby?branch=master)
 
 <img src="./assets/temporal_logo.png" width="250" align="right" alt="Temporal" />
 
 A pure Ruby library for defining and running Temporal workflows and activities.
 
-To find more about Temporal please visit <https://temporal.io/>.
+To find more about Temporal itself please visit <https://temporal.io/>.
 
 
 ## Getting Started

examples/.env

@@ -0,0 +1 @@
+COMPOSE_PROJECT_NAME=temporal-ruby-examples

examples/bin/worker

@@ -31,6 +31,7 @@ worker.register_workflow(HelloWorldWorkflow)
 worker.register_workflow(LocalHelloWorldWorkflow)
 worker.register_workflow(LongWorkflow)
 worker.register_workflow(LoopWorkflow)
+worker.register_workflow(MetadataWorkflow)
 worker.register_workflow(ParentWorkflow)
 worker.register_workflow(ProcessFileWorkflow)
 worker.register_workflow(QuickTimeoutWorkflow)
@@ -39,9 +40,11 @@ worker.register_workflow(ReleaseWorkflow)
 worker.register_workflow(ResultWorkflow)
 worker.register_workflow(SerialHelloWorldWorkflow)
 worker.register_workflow(SideEffectWorkflow)
+worker.register_workflow(SignalWithStartWorkflow)
 worker.register_workflow(SimpleTimerWorkflow)
 worker.register_workflow(TimeoutWorkflow)
 worker.register_workflow(TripBookingWorkflow)
+worker.register_workflow(WaitForWorkflow)
 
 worker.register_activity(AsyncActivity)
 worker.register_activity(EchoActivity)

examples/spec/integration/activity_cancellation_spec.rb

@@ -0,0 +1,39 @@
+require 'workflows/long_workflow'
+
+describe 'Activity cancellation' do
+  let(:workflow_id) { SecureRandom.uuid }
+
+  it 'cancels a running activity' do
+    run_id = Temporal.start_workflow(LongWorkflow, options: { workflow_id: workflow_id })
+
+    # Signal workflow after starting, allowing it to schedule the first activity
+    sleep 0.5
+    Temporal.signal_workflow(LongWorkflow, :CANCEL, workflow_id, run_id)
+
+    result = Temporal.await_workflow_result(
+      LongWorkflow,
+      workflow_id: workflow_id,
+      run_id: run_id,
+    )
+
+    expect(result).to be_a(LongRunningActivity::Canceled)
+    expect(result.message).to eq('cancel activity request received')
+  end
+
+  it 'cancels a non-started activity' do
+    # Workflow is started with a signal which will cancel an activity before it has started
+    run_id = Temporal.start_workflow(LongWorkflow, options: {
+      workflow_id: workflow_id,
+      signal_name: :CANCEL
+    })
+
+    result = Temporal.await_workflow_result(
+      LongWorkflow,
+      workflow_id: workflow_id,
+      run_id: run_id,
+    )
+
+    expect(result).to be_a(Temporal::ActivityCanceled)
+    expect(result.message).to eq('ACTIVITY_ID_NOT_STARTED')
+  end
+end

examples/spec/integration/await_workflow_result_spec.rb

@@ -95,7 +95,9 @@
     run_id = Temporal.start_workflow(
       LoopWorkflow,
       2, # it continues as new if this arg is > 1
-      { options: { workflow_id: workflow_id } },
+      options: {
+        workflow_id: workflow_id,
+      },
     )
 
     expect do

examples/spec/integration/continue_as_new_spec.rb

@@ -0,0 +1,49 @@
+require 'workflows/loop_workflow'
+
+describe LoopWorkflow do
+  it 'workflow continues as new into a new run' do
+    workflow_id = SecureRandom.uuid
+    memo = {
+        'my-memo' => 'foo',
+    }
+    headers = {
+        'my-header' => 'bar',
+    }
+    run_id = Temporal.start_workflow(
+      LoopWorkflow,
+      2, # it continues as new if this arg is > 1
+      options: {
+        workflow_id: workflow_id,
+        memo: memo,
+        headers: headers,
+      },
+    )
+
+    # First run will throw because it continued as new
+    next_run_id = nil
+    expect do
+      Temporal.await_workflow_result(
+        LoopWorkflow,
+        workflow_id: workflow_id,
+        run_id: run_id,
+      )
+    end.to raise_error(Temporal::WorkflowRunContinuedAsNew) do |error|
+      next_run_id = error.new_run_id
+    end
+
+    expect(next_run_id).to_not eq(nil)
+
+    # Second run will not throw because it returns rather than continues as new.
+    final_result = Temporal.await_workflow_result(
+      LoopWorkflow,
+      workflow_id: workflow_id,
+      run_id: next_run_id,
+    )
+
+    expect(final_result[:count]).to eq(1)
+
+    # memo and headers should be copied to the next run automatically
+    expect(final_result[:memo]).to eq(memo)
+    expect(final_result[:headers]).to eq(headers)
+  end
+end

examples/spec/integration/describe_namespace_spec.rb

@@ -0,0 +1,16 @@
+require 'temporal/errors'
+
+describe 'Temporal.describe_namespace' do
+  it 'returns a value' do
+    description = 'Namespace for temporal-ruby integration test'
+    begin
+      Temporal.register_namespace('a_test_namespace', description)
+    rescue Temporal::NamespaceAlreadyExistsFailure
+    end
+    result = Temporal.describe_namespace('a_test_namespace')
+    expect(result).to be_an_instance_of(Temporal::Api::WorkflowService::V1::DescribeNamespaceResponse)
+    expect(result.namespace_info.name).to eq('a_test_namespace')
+    expect(result.namespace_info.state).to eq(:NAMESPACE_STATE_REGISTERED)
+    expect(result.namespace_info.description).to eq(description)
+  end
+end

examples/spec/integration/metadata_workflow_spec.rb

@@ -0,0 +1,91 @@
+require 'workflows/metadata_workflow'
+
+describe MetadataWorkflow do
+  subject { described_class }
+
+  it 'gets task queue from running workflow' do
+    workflow_id = 'task-queue-' + SecureRandom.uuid
+    run_id = Temporal.start_workflow(
+      subject,
+      options: { workflow_id: workflow_id }
+    )
+
+    actual_result = Temporal.await_workflow_result(
+      subject,
+      workflow_id: workflow_id,
+      run_id: run_id,
+    )
+
+    expect(actual_result.task_queue).to eq(Temporal.configuration.task_queue)
+  end
+
+  it 'workflow can retrieve its headers' do
+    workflow_id = 'header_test_wf-' + SecureRandom.uuid
+
+    run_id = Temporal.start_workflow(
+      MetadataWorkflow,
+      options: {
+          workflow_id: workflow_id,
+          headers: { 'foo' => 'bar' },
+      }
+    )
+
+    actual_result = Temporal.await_workflow_result(
+      MetadataWorkflow,
+      workflow_id: workflow_id,
+      run_id: run_id,
+    )
+    expect(actual_result.headers).to eq({ 'foo' => 'bar' })
+  end
+
+  it 'workflow can retrieve its run started at' do
+    workflow_id = 'started_at_test_wf-' + SecureRandom.uuid
+
+    run_id = Temporal.start_workflow(
+      MetadataWorkflow,
+      options: { workflow_id: workflow_id }
+    )
+
+    actual_result = Temporal.await_workflow_result(
+      MetadataWorkflow,
+      workflow_id: workflow_id,
+      run_id: run_id,
+    )
+    expect(Time.now - actual_result.run_started_at).to be_between(0, 30)
+  end
+
+  it 'gets memo from workflow execution info' do
+    workflow_id = 'memo_execution_test_wf-' + SecureRandom.uuid
+    run_id = Temporal.start_workflow(subject, options: { workflow_id: workflow_id, memo: { 'foo' => 'bar' } })
+
+    actual_result = Temporal.await_workflow_result(
+      subject,
+      workflow_id: workflow_id,
+      run_id: run_id,
+    )
+    expect(actual_result.memo['foo']).to eq('bar')
+
+    expect(Temporal.fetch_workflow_execution_info(
+      'ruby-samples', workflow_id, nil
+    ).memo).to eq({ 'foo' => 'bar' })
+  end
+
+  it 'gets memo from workflow context with no memo' do
+    workflow_id = 'memo_context_no_memo_test_wf-' + SecureRandom.uuid
+
+    run_id = Temporal.start_workflow(
+      subject,
+      options: { workflow_id: workflow_id }
+    )
+
+    actual_result = Temporal.await_workflow_result(
+      subject,
+      workflow_id: workflow_id,
+      run_id: run_id,
+    )
+    expect(actual_result.memo).to eq({})
+    expect(Temporal.fetch_workflow_execution_info(
+      'ruby-samples', workflow_id, nil
+    ).memo).to eq({})
+  end
+end

examples/spec/integration/signal_with_start_spec.rb

@@ -0,0 +1,75 @@
+require 'workflows/signal_with_start_workflow'
+
+describe 'signal with start' do
+
+  it 'signals at workflow start time' do
+    workflow_id = SecureRandom.uuid
+    run_id = Temporal.start_workflow(
+      SignalWithStartWorkflow,
+      'signal_name',
+      0.1,
+      options: {
+        workflow_id: workflow_id,
+        signal_name: 'signal_name',
+        signal_input: 'expected value',
+      }
+    )
+
+    result = Temporal.await_workflow_result(
+      SignalWithStartWorkflow,
+      workflow_id: workflow_id,
+      run_id: run_id,
+    )
+
+    expect(result).to eq('expected value') # the workflow should return the signal value
+  end
+
+  it 'signals at workflow start time with name only' do
+    workflow_id = SecureRandom.uuid
+    run_id = Temporal.start_workflow(
+      SignalWithStartWorkflow,
+      'signal_name',
+      0.1,
+      options: {
+        workflow_id: workflow_id,
+        signal_name: 'signal_name',
+      }
+    )
+
+    result = Temporal.await_workflow_result(
+      SignalWithStartWorkflow,
+      workflow_id: workflow_id,
+      run_id: run_id,
+    )
+
+    expect(result).to eq(nil) # the workflow should return the signal value
+  end
+
+  it 'does not launch a new workflow when signaling a running workflow through signal_with_start' do
+    workflow_id = SecureRandom.uuid
+    run_id = Temporal.start_workflow(
+      SignalWithStartWorkflow,
+      'signal_name',
+      10,
+      options: {
+        workflow_id: workflow_id,
+        signal_name: 'signal_name',
+        signal_input: 'expected value',
+      }
+    )
+
+    second_run_id = Temporal.start_workflow(
+      SignalWithStartWorkflow,
+      'signal_name',
+      0.1,
+      options: {
+        workflow_id: workflow_id,
+        signal_name: 'signal_name',
+        signal_input: 'expected value',
+      }
+    )
+
+    # If the run ids are the same, then we didn't start a new workflow
+    expect(second_run_id).to eq(run_id)
+  end
+end

examples/spec/integration/wait_for_workflow_spec.rb

@@ -0,0 +1,28 @@
+require 'workflows/wait_for_workflow'
+
+describe WaitForWorkflow do
+
+  it 'signals at workflow start time' do
+    workflow_id = SecureRandom.uuid
+    run_id = Temporal.start_workflow(
+      WaitForWorkflow,
+      10, # number of echo activities to run
+      2, # max activity parallelism
+      'signal_name',
+      options: { workflow_id: workflow_id }
+    )
+
+    Temporal.signal_workflow(WaitForWorkflow, 'signal_name', workflow_id, run_id)
+
+    result = Temporal.await_workflow_result(
+      WaitForWorkflow,
+      workflow_id: workflow_id,
+      run_id: run_id,
+    )
+
+    expect(result.length).to eq(3)
+    expect(result[:signal]).to eq(true)
+    expect(result[:timer]).to eq(true)
+    expect(result[:activity]).to eq(true)
+  end
+end

examples/workflows/long_workflow.rb

@@ -9,6 +9,6 @@ def execute(cycles = 10, interval = 1)
       future.cancel
     end
 
-    future.wait
+    future.get
   end
 end

examples/workflows/loop_workflow.rb

@@ -8,6 +8,10 @@ def execute(count)
       return workflow.continue_as_new(count - 1)
     end
 
-    return count
+    return {
+      count: count,
+      memo: workflow.metadata.memo,
+      headers: workflow.metadata.headers,
+    }
   end
 end

examples/workflows/metadata_workflow.rb

@@ -0,0 +1,5 @@
+class MetadataWorkflow < Temporal::Workflow
+  def execute
+    workflow.metadata
+  end
+end

examples/workflows/signal_with_start_workflow.rb

@@ -0,0 +1,16 @@
+class SignalWithStartWorkflow < Temporal::Workflow
+
+  def execute(expected_signal, sleep_for)
+    received = 'no signal received'
+
+    workflow.on_signal do |signal, input|
+      if signal == expected_signal
+        received = input
+      end
+    end
+
+    # Do something to get descheduled so the signal handler has a chance to run
+    workflow.sleep(sleep_for)
+    received
+  end
+end