86244

pending completion

Build # 86244

Build Type

cron

travis-ci-com

Committed by

Fryguy

Commit Message

<a href="https://github.com/ManageIQ/manageiq/commit/<a class=hub.com/ManageIQ/manageiq/commit/61cd4a556ec5d3695071e14ca1773b68ce94a43f">61cd4a556<a href="https://github.com/ManageIQ/manageiq/commit/61cd4a556ec5d3695071e14ca1773b68ce94a43f">&quot;&gt;Merge pull request #21603 from agrare/fix_ems_event_manager_refresh

Fix EmsEvent#manager_refresh full-refresh target

(cherry picked from commit </a><a class="double-link" href="https://github.com/ManageIQ/manageiq/commit/<a class="double-link" href="https://github.com/ManageIQ/manageiq/commit/5aafeca5c46c13c807297bf379ef47901d42a36a">5aafeca5c</a>">5aafeca5c</a><a href="https://github.com/ManageIQ/manageiq/commit/61cd4a556ec5d3695071e14ca1773b68ce94a43f">)

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

32452 of 53356 relevant lines covered (60.82%)

463.76 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

44.12

/app/models/ems_event/automate.rb

class EmsEvent
  module Automate
    extend ActiveSupport::Concern

    def manager_refresh(sync: false)
      refresh_targets = manager_refresh_targets

      return if refresh_targets.blank?

      EmsRefresh.queue_refresh(refresh_targets, nil, :create_task => sync)
    end

    def refresh(*targets, sync)
      return if ext_management_system&.supports_streaming_refresh?

      targets = targets.flatten
      return if targets.blank?

      refresh_targets = targets.collect { |t| get_target("#{t}_refresh_target") unless t.blank? }.compact.uniq
      return if refresh_targets.empty?

      EmsRefresh.queue_refresh(refresh_targets, nil, :create_task => sync)
    end

    def policy(target_str, policy_event, param = nil)
      _log.debug("ems: [#{ems_id}]")
      return if ems_id.nil?

      target, policy_event, policy_src = parse_policy_parameters(target_str, policy_event, param)
      return if target.nil? || policy_event.nil? || policy_src.nil?

      inputs = {
        policy_src.class.table_name.to_sym            => policy_src,
        :ems_event                                    => self
      }
      begin
        MiqEvent.raise_evm_event(target, policy_event, inputs)
      rescue => err
        _log.log_backtrace(err)
      end
    end

    def scan(*targets)
      _log.debug("Targets: [#{targets.inspect}]")

      missing_targets = targets.each_with_object([]) do |t, arr|
        target = get_target(t)
        if target.nil?
          # Queue that target for refresh instead
          _log.info("Unable to find target [#{t}].  Queueing for refresh.")
          arr << t
        else
          _log.info("Scanning [#{t}] [#{target.id}] name: [#{target.name}]")
          target.scan
        end
      end

      unless missing_targets.empty?
        _log.info("Performing refresh on the targets that were not found #{missing_targets.inspect}.")
        refresh(*missing_targets)
      end
    end

    def src_vm_as_template(flag)
      options = {
        :param => flag,
        :save  => true
      }

      call("src_vm", "template=", options)
    end

    def change_event_target_state(target_str, param)
      options = {
        :param => param,
        :save  => true
      }

      target = get_target(target_str)
      method = target.respond_to?(:raw_power_state=) ? "raw_power_state=" : "state="
      call(target_str, method, options)
    end

    def src_vm_destroy_all_snapshots
      call("src_vm", "snapshots.destroy_all")
    end

    private

    def parse_policy_parameters(target_str, policy_event, param)
      target         = get_target(target_str)     unless target_str.blank?
      policy_event ||= event_type
      policy_src     = parse_policy_source(target, param) if target

      _log.warn("Unable to find target [#{target_str}], skipping policy evaluation") if target.nil?
      _log.debug("Target: [#{target_str}], Policy event: [#{policy_event}]")
      _log.debug("Target object: [#{target.inspect}]")
      _log.debug("Policy source: [#{policy_src}]")

      [target, policy_event, policy_src]
    end

    def parse_policy_source(target, param)
      param.blank? ? ext_management_system : target.send(param)
    rescue => err
      _log.warn("Error: #{err.message}, getting policy source, skipping policy evaluation")
    end

    def call(target_str, method, options = {})
      return if target_str.nil? || method.nil?

      target = target_original = get_target(target_str)
      if target.nil?
        _log.info("Unable to find target [#{target_str}].  Performing refresh.")
        return refresh(target_str)
      end

      methods = method.split('.').collect { |m| [m] }
      methods[-1] << options[:param] if options.key?(:param)

      _log.info("Calling method [#{target.class}, #{target.id}].#{methods}")
      methods.each { |m| target = target.send(*m) }

      target_original.send(:save!) if options[:save] == true
    end
  end
end

1	class EmsEvent	2✔
2	module Automate	2✔
3	extend ActiveSupport::Concern	2✔
4
5	def manager_refresh(sync: false)	2✔
6	refresh_targets = manager_refresh_targets	×
7
8	return if refresh_targets.blank?	×
9
10	EmsRefresh.queue_refresh(refresh_targets, nil, :create_task => sync)	×
11	end
12
13	def refresh(*targets, sync)	2✔
14	return if ext_management_system&.supports_streaming_refresh?	×
15
16	targets = targets.flatten	×
17	return if targets.blank?	×
18
19	refresh_targets = targets.collect { \|t\| get_target("#{t}_refresh_target") unless t.blank? }.compact.uniq	×
20	return if refresh_targets.empty?	×
21
22	EmsRefresh.queue_refresh(refresh_targets, nil, :create_task => sync)	×
23	end
24
25	def policy(target_str, policy_event, param = nil)	2✔
26	_log.debug("ems: [#{ems_id}]")	2✔
27	return if ems_id.nil?	2✔
28
29	target, policy_event, policy_src = parse_policy_parameters(target_str, policy_event, param)	2✔
30	return if target.nil? \|\| policy_event.nil? \|\| policy_src.nil?	2✔
31
32	inputs = {
33	policy_src.class.table_name.to_sym => policy_src,	2✔
34	:ems_event => self
35	}
36	begin
37	MiqEvent.raise_evm_event(target, policy_event, inputs)	2✔
38	rescue => err
39	_log.log_backtrace(err)	2✔
40	end
41	end
42
43	def scan(*targets)	2✔
44	_log.debug("Targets: [#{targets.inspect}]")	×
45
46	missing_targets = targets.each_with_object([]) do \|t, arr\|	×
47	target = get_target(t)	×
48	if target.nil?	×
49	# Queue that target for refresh instead
50	_log.info("Unable to find target [#{t}]. Queueing for refresh.")	×
51	arr << t	×
52	else
53	_log.info("Scanning [#{t}] [#{target.id}] name: [#{target.name}]")	×
54	target.scan	×
55	end
56	end
57
58	unless missing_targets.empty?	×
59	_log.info("Performing refresh on the targets that were not found #{missing_targets.inspect}.")	×
60	refresh(*missing_targets)	×
61	end
62	end
63
64	def src_vm_as_template(flag)	2✔
65	options = {
66	:param => flag,	×
67	:save => true
68	}
69
70	call("src_vm", "template=", options)	×
71	end
72
73	def change_event_target_state(target_str, param)	2✔
74	options = {
75	:param => param,	×
76	:save => true
77	}
78
79	target = get_target(target_str)	×
80	method = target.respond_to?(:raw_power_state=) ? "raw_power_state=" : "state="	×
81	call(target_str, method, options)	×
82	end
83
84	def src_vm_destroy_all_snapshots	2✔
85	call("src_vm", "snapshots.destroy_all")	×
86	end
87
88	private	2✔
89
90	def parse_policy_parameters(target_str, policy_event, param)	2✔
91	target = get_target(target_str) unless target_str.blank?	2✔
92	policy_event \|\|= event_type	2✔
93	policy_src = parse_policy_source(target, param) if target	2✔
94
95	_log.warn("Unable to find target [#{target_str}], skipping policy evaluation") if target.nil?	2✔
96	_log.debug("Target: [#{target_str}], Policy event: [#{policy_event}]")	2✔
97	_log.debug("Target object: [#{target.inspect}]")	2✔
98	_log.debug("Policy source: [#{policy_src}]")	2✔
99
100	[target, policy_event, policy_src]	2✔
101	end
102
103	def parse_policy_source(target, param)	2✔
104	param.blank? ? ext_management_system : target.send(param)	2✔
105	rescue => err
106	_log.warn("Error: #{err.message}, getting policy source, skipping policy evaluation")	×
107	end
108
109	def call(target_str, method, options = {})	2✔
110	return if target_str.nil? \|\| method.nil?	×
111
112	target = target_original = get_target(target_str)	×
113	if target.nil?	×
114	_log.info("Unable to find target [#{target_str}]. Performing refresh.")	×
115	return refresh(target_str)	×
116	end
117
118	methods = method.split('.').collect { \|m\| [m] }	×
119	methods[-1] << options[:param] if options.key?(:param)	×
120
121	_log.info("Calling method [#{target.class}, #{target.id}].#{methods}")	×
122	methods.each { \|m\| target = target.send(*m) }	×
123
124	target_original.send(:save!) if options[:save] == true	×
125	end
126	end
127	end

ManageIQ / manageiq / 86244

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous