Merge upstream (#5)

* Pass config to the error handler instead of using the global config

* Fix example tests

* Make the config property in the workflow context publicly readable

* [Fix] Retryer GRPC error lookup (coinbase#109)

* Fix issue with GRPC error lookup in Retryer

* Rename spec file for retryer to contain _spec

* [Feature] Add id and domain to workflow context's metadata (coinbase#110)

* Start syncing id and domain on workflow context metadata

* Fixed tests

Co-authored-by: DeRauk Gibble <derauk.gibble@coinbase.com>

* Explicit docker-compose project name (coinbase#114)

* Add YARD documentation for Temporal::Client (coinbase#113)

* Add YARD documentation for Temporal::Client

* Add yard gem

* Fix @option tag

* Typo fix

* Add signal arguments to start_workflow (support for signal_with_start) (coinbase#112)

* Add signal arguments to start_workflow (to support signal_with_start)

* Move signal arguments to the options hash

* PR feedback

* Fix merge error

* Extend #wait_for to take multiple futures and a condition block (coinbase#111)

* Differentiate TARGET_WILDCARD and WILDCARD, allow comparison with EventTarget objects (coinbase#118)

* Turn off schedule_to_start activity timeout by default (coinbase#119)

* Separate options from keyword args in #start_workflow (coinbase#117)

* Separate options from keyword args in #start_workflow

* fixup! Separate options from keyword args in #start_workflow

* Surface additional workflow metadata on workflow context (coinbase#120)

* Refactor metadata generation

* Make task queue available on workflow metadata, add example test

* Expose workflow start time metadata

* Add memos (coinbase#121)

* Add describe_namespace (coinbase#122)

* Add describe_namespace

* Feedback

* Improve header serialization and propagation (coinbase#124)

* [Fix] Non-started activity cancellation (coinbase#125)

* Fix event target map entry for ACTIVITY_CANCELED event

* Fix cancellation of a non-started activity

* fixup! Fix event target map entry for ACTIVITY_CANCELED event

Co-authored-by: DeRauk Gibble <derauk.gibble@coinbase.com>
Co-authored-by: DeRauk Gibble <derauk@gmail.com>
Co-authored-by: Anthony Dmitriyev <antstorm@gmail.com>
Co-authored-by: nagl-stripe <86737162+nagl-stripe@users.noreply.github.com>
Co-authored-by: jeffschoner-stripe <63118764+jeffschoner-stripe@users.noreply.github.com>
Co-authored-by: Drew Hoskins <37816070+drewhoskins-stripe@users.noreply.github.com>

Author: 6 people

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