Module: Proxy::Dynflow::Helpers

Defined in:
lib/smart_proxy_dynflow/helpers.rb

Instance Method Summary collapse

Instance Method Details

#authorize_with_token(task_id:, clear: true) ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
# File 'lib/smart_proxy_dynflow/helpers.rb', line 8

def authorize_with_token(task_id:, clear: true)
  if request.env.key? 'HTTP_AUTHORIZATION'
    if defined?(::Proxy::Dynflow)
      auth = request.env['HTTP_AUTHORIZATION']
      basic_prefix = /\ABasic /
      if !auth.to_s.empty? && auth =~ basic_prefix &&
         Proxy::Dynflow::OtpManager.authenticate(auth.gsub(basic_prefix, ''),
                                                 expected_user: task_id, clear: clear)
        Log.instance.debug('authorized with token')
        return true
      end
    end
    halt 403, MultiJson.dump(:error => 'Invalid username or password supplied')
  end
  false
end

#cancel_task(task_id) ⇒ Object 



30
31
32
33
34
 
# File 'lib/smart_proxy_dynflow/helpers.rb', line 30

def cancel_task(task_id)
  execution_plan = world.persistence.load_execution_plan(task_id)
  cancel_events = execution_plan.cancel
  { :task_id => task_id, :canceled_steps_count => cancel_events.size }
end

#dispatch_external_event(task_id, params) ⇒ Object 



55
56
57
58
59
 
# File 'lib/smart_proxy_dynflow/helpers.rb', line 55

def dispatch_external_event(task_id, params)
  world.event(task_id,
              params['step_id'].to_i,
              ::Proxy::Dynflow::Runner::ExternalEvent.new(params))
end

#expand_output(action) ⇒ Object 



67
68
69
70
71
 
# File 'lib/smart_proxy_dynflow/helpers.rb', line 67

def expand_output(action)
  hash = action.to_hash
  hash[:output][:result] = action.output_result if action.is_a?(Proxy::Dynflow::Action::Runner)
  hash
end

#refresh_output(execution_plan, action) ⇒ Object 



61
62
63
64
65
 
# File 'lib/smart_proxy_dynflow/helpers.rb', line 61

def refresh_output(execution_plan, action)
  if action.is_a?(Proxy::Dynflow::Action::WithExternalPolling) && %i[running suspended].include?(action.run_step&.state)
    world.event(execution_plan.id, action.run_step_id, Proxy::Dynflow::Action::WithExternalPolling::Poll)
  end
end

#task_status(task_id) ⇒ Object 



36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/smart_proxy_dynflow/helpers.rb', line 36

def task_status(task_id)
  ep = world.persistence.load_execution_plan(task_id)
  actions = ep.actions.map do |action|
    refresh_output(ep, action)
    expand_output(action)
  end
  ep.to_hash.merge(:actions => actions)
rescue KeyError => _e
  status 404
  {}
end

#tasks_count(state) ⇒ Object 



48
49
50
51
52
53
 
# File 'lib/smart_proxy_dynflow/helpers.rb', line 48

def tasks_count(state)
  state ||= 'all'
  filter = state != 'all' ? { :filters => { :state => [state] } } : {}
  tasks = world.persistence.find_execution_plans(filter)
  { :count => tasks.count, :state => state }
end

#trigger_task(*args) ⇒ Object 



25
26
27
28
 
# File 'lib/smart_proxy_dynflow/helpers.rb', line 25

def trigger_task(*args)
  triggered = world.trigger(*args)
  { :task_id => triggered.id }
end

#world ⇒ Object 



4
5
6
 
# File 'lib/smart_proxy_dynflow/helpers.rb', line 4

def world
  Proxy::Dynflow::Core.world
end