Module: Trailblazer::Activity::TaskWrap

Defined in:
lib/trailblazer/activity/task_wrap.rb,
lib/trailblazer/activity/task_wrap/runner.rb,
lib/trailblazer/activity/task_wrap/pipeline.rb,
lib/trailblazer/activity/task_wrap/call_task.rb,
lib/trailblazer/activity/task_wrap/variable_mapping.rb

Overview

Example with tracing:

Call the task_wrap circuit:

|-- Start
|-- Trace.capture_args   [optional]
|-- Call (call actual task) id: "task_wrap.call_task"
|-- Trace.capture_return [optional]
|-- Wrap::End

Defined Under Namespace

Modules: Runner, VariableMapping Classes: Extension, Input, Output, Pipeline

Class Method Summary collapse

Class Method Details

.call_task(wrap_ctx, original_args) ⇒ Object

TaskWrap step that calls the actual wrapped task and passes all ‘original_args` to it.

It writes to wrap_ctx, wrap_ctx



6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
# File 'lib/trailblazer/activity/task_wrap/call_task.rb', line 6

def self.call_task(wrap_ctx, original_args)
  task = wrap_ctx[:task]

  original_arguments, original_circuit_options = original_args

  # Call the actual task we're wrapping here.
  # puts "~~~~wrap.call: #{task}"
  return_signal, return_args = task.(original_arguments, **original_circuit_options)

  # DISCUSS: do we want original_args here to be passed on, or the "effective" return_args which are different to original_args now?
  wrap_ctx = wrap_ctx.merge( return_signal: return_signal, return_args: return_args )

  return wrap_ctx, original_args
end

.Extension(merge:) ⇒ Object

Use this in your macros if you want to extend the taskWrap.



41
42
43
 
# File 'lib/trailblazer/activity/task_wrap.rb', line 41

def Extension(merge:)
  Extension.new(merge: Pipeline::Merge.new(*merge))
end

.initial_wrap_static ⇒ Object

:extension API Extend the static taskWrap from a macro or DSL call. Gets executed in Intermediate.call which also provides config.



35
36
37
38
 
# File 'lib/trailblazer/activity/task_wrap.rb', line 35

def initial_wrap_static(*)
  # return initial_sequence
  TaskWrap::Pipeline.new([["task_wrap.call_task", TaskWrap.method(:call_task)]])
end

.invoke(activity, args, wrap_runtime: {}, wrap_static: initial_wrap_static, **circuit_options) ⇒ Object

Compute runtime arguments necessary to execute a taskWrap per task of the activity. This method is the top-level entry, called only once for the entire activity graph.

:wrap_static

The taskWrap used for the topmost activity/operation.



18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/trailblazer/activity/task_wrap.rb', line 18

def invoke(activity, args, wrap_runtime: {}, wrap_static: initial_wrap_static, **circuit_options) # FIXME: why do we need this method?
  circuit_options = circuit_options.merge(
    runner:       TaskWrap::Runner,
    wrap_runtime: wrap_runtime,
    # This {:activity} structure is currently (?) only needed in {TaskWrap.wrap_static_for}, where we
    # access {activity[:wrap_static]} to compile the effective taskWrap.
    activity:     {wrap_static: {activity => wrap_static}, nodes: {}}, # for Runner. Ideally we'd have a list of all static_wraps here (even nested).
  )

  # signal, (ctx, flow), circuit_options =
  TaskWrap::Runner.(activity, args, **circuit_options)
end

.wrap_static_for(task, activity:) ⇒ Object

Retrieve the static wrap config from activity.



47
48
49
50
 
# File 'lib/trailblazer/activity/task_wrap/runner.rb', line 47

def self.wrap_static_for(task, activity:, **)
  wrap_static = activity[:wrap_static]
  wrap_static[task] or raise "#{task}"
end