84678

pending completion

Build # 84678

Build Type

push

travis-ci-com

Committed by

Fryguy

Commit Message

<a href="https://github.com/ManageIQ/manageiq/commit/<a class=hub.com/ManageIQ/manageiq/commit/e90df112c35d923f60d90496f589ea71e0215564">e90df112c<a href="https://github.com/ManageIQ/manageiq/commit/e90df112c35d923f60d90496f589ea71e0215564">&quot;&gt;Merge pull request IBMPrivateCloud/bluecf#1 from Jason-Frey/remove_eval

Fix eval of user-input inside of a numeric_set expression

(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/75a00c69b66b1cdc08658efb35ce6047516c2842">75a00c69b</a>">75a00c69b</a><a href="https://github.com/ManageIQ/manageiq/commit/e90df112c35d923f60d90496f589ea71e0215564">)

Run Details

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

33536 of 53710 relevant lines covered (62.44%)

224.12 hits per line

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

56.1

/app/models/miq_event.rb

class MiqEvent < EventStream
  CHILD_EVENTS = {
    :assigned_company_tag   => {
      :Host         => [:vms_and_templates],
      :EmsCluster   => [:all_vms_and_templates],
      :Storage      => [:vms_and_templates],
      :ResourcePool => [:vms_and_templates]
    },
    :unassigned_company_tag => {
      :Host         => [:vms_and_templates],
      :EmsCluster   => [:all_vms_and_templates],
      :Storage      => [:vms_and_templates],
      :ResourcePool => [:vms_and_templates]
    }
  }

  SUPPORTED_POLICY_AND_ALERT_CLASSES = [Host, VmOrTemplate, Storage,
                                        EmsCluster, ResourcePool, MiqServer,
                                        ExtManagementSystem,
                                        ContainerReplicator, ContainerGroup, ContainerProject,
                                        ContainerNode, ContainerImage, PhysicalServer].freeze

  def self.raise_evm_event(target, raw_event, inputs = {}, options = {})
    # Target may have been deleted if it's a worker
    # Target, in that case will be the worker's server.
    # The generic raw_event remains, but client can pass the :type of the worker spawning the event:
    #  ex: MiqEvent.raise_evm_event(w.miq_server, "evm_worker_not_responding", :type => "MiqGenericWorker", :event_details => "MiqGenericWorker with pid 1234 killed due to not responding")
    # Policy, automate, and alerting could then consume this type field along with the details
    if target.kind_of?(Array)
      klass, id = target
      target = klass.to_s.constantize.find_by(:id => id)
    end
    raise "Unable to find object for target: [#{target}]" unless target

    event = normalize_event(raw_event.to_s)
    if event == 'unknown' && target.class.base_class.in?(SUPPORTED_POLICY_AND_ALERT_CLASSES)
      _log.warn("Event #{raw_event} for class [#{target.class.name}] id [#{target.id}] was not raised: #{raw_event} is not defined in MiqEventDefinition")
      _log.info("Alert for Event [#{raw_event}]")
      MiqAlert.evaluate_alerts(target, raw_event, inputs) if MiqAlert.event_alertable?(raw_event)
      return
    end

    event_obj = build_evm_event(event, target, inputs[:full_data])
    inputs.merge!('MiqEvent::miq_event' => event_obj.id, :miq_event_id => event_obj.id)
    inputs.merge!('EventStream::event_stream' => event_obj.id, :event_stream_id => event_obj.id)

    # save the EmsEvent that are required by some actions later in policy resolution
    event_obj.update(:full_data => {:source_event_id => inputs[:ems_event].id}) if inputs[:ems_event]

    MiqAeEvent.raise_evm_event(raw_event, target, inputs, options)
    event_obj
  end

  def process_evm_event(inputs = {})
    return if target.nil?

    return unless target.class.base_class.in?(SUPPORTED_POLICY_AND_ALERT_CLASSES)
    raise "Unable to find object with class: [#{target_class}], Id: [#{target_id}]" unless target

    results = {}
    inputs[:type] ||= target.class.name
    inputs[:source_event] = source_event if source_event
    inputs[:triggering_type] = event_type
    inputs[:triggering_data] = full_data

    _log.info("Event Raised [#{event_type}]")
    begin
      results[:policy] = MiqPolicy.enforce_policy(target, event_type, inputs)
      update_with_policy_result(results)
      update(:message => 'Policy resolved successfully!')
    rescue MiqException::PolicyPreventAction => err
      update(:full_data => {:policy => {:prevented => true}}, :message => err.message)
    end

    _log.info("Alert for Event [#{event_type}]")
    results[:alert] = MiqAlert.evaluate_alerts(target, event_type, inputs)

    results[:children_events] = self.class.raise_event_for_children(target, event_type, inputs)

    results
  end

  def self.build_evm_event(event, target, full_data = nil)
    options = {
      :event_type => event,
      :target     => target,
      :full_data  => full_data,
      :source     => 'POLICY',
      :timestamp  => Time.now.utc
    }
    user = User.current_user
    options.merge!(:user_id => user.id, :group_id => user.current_group.id, :tenant_id => user.current_tenant.id) if user
    MiqEvent.create(options)
  end

  def update_with_policy_result(result = {})
    if result.fetch_path(:policy, :actions, :assign_scan_profile)
      update(
        :full_data => {
          :policy => {
            :actions => {
              :assign_scan_profile => result.fetch_path(:policy, :actions, :assign_scan_profile)
            }
          }
        }
      )
    end
  end

  def self.normalize_event(event)
    return event if MiqEventDefinition.find_by(:name => event)
    "unknown"
  end

  def self.raise_evm_event_queue_in_region(target, raw_event, inputs = {})
    MiqQueue.put(
      :zone        => nil,
      :class_name  => name,
      :method_name => 'raise_evm_event',
      :args        => [[target.class.name, target.id], raw_event, inputs]
    )
  end

  def self.raise_evm_event_queue(target, raw_event, inputs = {})
    MiqQueue.put(
      :class_name  => name,
      :method_name => 'raise_evm_event',
      :args        => [[target.class.name, target.id], raw_event, inputs]
    )
  end

  def self.raise_evm_alert_event_queue(target, raw_event, inputs = {})
    MiqQueue.put_unless_exists(
      :class_name  => "MiqAlert",
      :method_name => 'evaluate_alerts',
      :args        => [[target.class.name, target.id], raw_event, inputs]
    ) if MiqAlert.alarm_has_alerts?(raw_event)
  end

  def self.raise_evm_job_event(target, options = {}, inputs = {}, q_options = {})
    # Eg. options = {:type => "scan", ":prefix => "request, :suffix => "abort"}
    options.reverse_merge!(
      :type   => "scan",
      :prefix => nil,
      :suffix => nil
    )

    target_model = target.class.base_model.name.downcase
    target_model = "vm" if target_model.match("template")

    base_event = [target_model, options[:type]].join("_")
    evm_event  = [options[:prefix], base_event, options[:suffix]].compact.join("_")
    raise_evm_event(target, evm_event, inputs, q_options)
  end

  def self.raise_event_for_children(target, raw_event, inputs = {})
    child_assocs = CHILD_EVENTS.fetch_path(raw_event.to_sym, target.class.base_class.name.to_sym)
    return if child_assocs.blank?

    child_event = "#{raw_event}_parent_#{target.class.base_model.name.underscore}"
    child_assocs.each do |assoc|
      next unless target.respond_to?(assoc)
      children = target.send(assoc)
      children.each do |child|
        _log.info("Raising Event [#{child_event}] for Child [(#{child.class}) #{child.name}] of Parent [(#{target.class}) #{target.name}]")
        raise_evm_event_queue(child, child_event, inputs)
      end
    end
  end

  def self.event_name_for_target(target, event_suffix)
    "#{target.class.base_model.name.underscore}_#{event_suffix}"
  end

  # return the event that triggered the policy event
  def source_event
    return @source_event if @source_event
    return unless full_data

    source_event_id = full_data.fetch_path(:source_event_id)
    @source_event = EventStream.find_by(:id => source_event_id) if source_event_id
  end

  def self.display_name(number = 1)
    n_('Event', 'Events', number)
  end
end

1	class MiqEvent < EventStream	1✔
2	CHILD_EVENTS = {
3	:assigned_company_tag => {	1✔
4	:Host => [:vms_and_templates],
5	:EmsCluster => [:all_vms_and_templates],
6	:Storage => [:vms_and_templates],
7	:ResourcePool => [:vms_and_templates]
8	},
9	:unassigned_company_tag => {
10	:Host => [:vms_and_templates],
11	:EmsCluster => [:all_vms_and_templates],
12	:Storage => [:vms_and_templates],
13	:ResourcePool => [:vms_and_templates]
14	}
15	}
16
17	SUPPORTED_POLICY_AND_ALERT_CLASSES = [Host, VmOrTemplate, Storage,	1✔
18	EmsCluster, ResourcePool, MiqServer,
19	ExtManagementSystem,
20	ContainerReplicator, ContainerGroup, ContainerProject,
21	ContainerNode, ContainerImage, PhysicalServer].freeze
22
23	def self.raise_evm_event(target, raw_event, inputs = {}, options = {})	1✔
24	# Target may have been deleted if it's a worker
25	# Target, in that case will be the worker's server.
26	# The generic raw_event remains, but client can pass the :type of the worker spawning the event:
27	# ex: MiqEvent.raise_evm_event(w.miq_server, "evm_worker_not_responding", :type => "MiqGenericWorker", :event_details => "MiqGenericWorker with pid 1234 killed due to not responding")
28	# Policy, automate, and alerting could then consume this type field along with the details
29	if target.kind_of?(Array)	434✔
30	klass, id = target	×
31	target = klass.to_s.constantize.find_by(:id => id)	×
32	end
33	raise "Unable to find object for target: [#{target}]" unless target	434✔
34
35	event = normalize_event(raw_event.to_s)	434✔
36	if event == 'unknown' && target.class.base_class.in?(SUPPORTED_POLICY_AND_ALERT_CLASSES)	434✔
37	_log.warn("Event #{raw_event} for class [#{target.class.name}] id [#{target.id}] was not raised: #{raw_event} is not defined in MiqEventDefinition")	414✔
38	_log.info("Alert for Event [#{raw_event}]")	414✔
39	MiqAlert.evaluate_alerts(target, raw_event, inputs) if MiqAlert.event_alertable?(raw_event)	414✔
40	return	414✔
41	end
42
43	event_obj = build_evm_event(event, target, inputs[:full_data])	20✔
44	inputs.merge!('MiqEvent::miq_event' => event_obj.id, :miq_event_id => event_obj.id)	20✔
45	inputs.merge!('EventStream::event_stream' => event_obj.id, :event_stream_id => event_obj.id)	20✔
46
47	# save the EmsEvent that are required by some actions later in policy resolution
48	event_obj.update(:full_data => {:source_event_id => inputs[:ems_event].id}) if inputs[:ems_event]	20✔
49
50	MiqAeEvent.raise_evm_event(raw_event, target, inputs, options)	20✔
51	event_obj	17✔
52	end
53
54	def process_evm_event(inputs = {})	1✔
55	return if target.nil?	×
56
57	return unless target.class.base_class.in?(SUPPORTED_POLICY_AND_ALERT_CLASSES)	×
58	raise "Unable to find object with class: [#{target_class}], Id: [#{target_id}]" unless target	×
59
60	results = {}	×
61	inputs[:type] \|\|= target.class.name	×
62	inputs[:source_event] = source_event if source_event	×
63	inputs[:triggering_type] = event_type	×
64	inputs[:triggering_data] = full_data	×
65
66	_log.info("Event Raised [#{event_type}]")	×
67	begin
68	results[:policy] = MiqPolicy.enforce_policy(target, event_type, inputs)	×
69	update_with_policy_result(results)	×
70	update(:message => 'Policy resolved successfully!')	×
71	rescue MiqException::PolicyPreventAction => err
72	update(:full_data => {:policy => {:prevented => true}}, :message => err.message)	×
73	end
74
75	_log.info("Alert for Event [#{event_type}]")	×
76	results[:alert] = MiqAlert.evaluate_alerts(target, event_type, inputs)	×
77
78	results[:children_events] = self.class.raise_event_for_children(target, event_type, inputs)	×
79
80	results	×
81	end
82
83	def self.build_evm_event(event, target, full_data = nil)	1✔
84	options = {
85	:event_type => event,	20✔
86	:target => target,
87	:full_data => full_data,
88	:source => 'POLICY',
89	:timestamp => Time.now.utc
90	}
91	user = User.current_user	20✔
92	options.merge!(:user_id => user.id, :group_id => user.current_group.id, :tenant_id => user.current_tenant.id) if user	20✔
93	MiqEvent.create(options)	20✔
94	end
95
96	def update_with_policy_result(result = {})	1✔
97	if result.fetch_path(:policy, :actions, :assign_scan_profile)	×
98	update(	×
99	:full_data => {
100	:policy => {
101	:actions => {
102	:assign_scan_profile => result.fetch_path(:policy, :actions, :assign_scan_profile)
103	}
104	}
105	}
106	)
107	end
108	end
109
110	def self.normalize_event(event)	1✔
111	return event if MiqEventDefinition.find_by(:name => event)	434✔
112	"unknown"	417✔
113	end
114
115	def self.raise_evm_event_queue_in_region(target, raw_event, inputs = {})	1✔
116	MiqQueue.put(	36✔
117	:zone => nil,
118	:class_name => name,
119	:method_name => 'raise_evm_event',
120	:args => [[target.class.name, target.id], raw_event, inputs]
121	)
122	end
123
124	def self.raise_evm_event_queue(target, raw_event, inputs = {})	1✔
125	MiqQueue.put(	55✔
126	:class_name => name,
127	:method_name => 'raise_evm_event',
128	:args => [[target.class.name, target.id], raw_event, inputs]
129	)
130	end
131
132	def self.raise_evm_alert_event_queue(target, raw_event, inputs = {})	1✔
133	MiqQueue.put_unless_exists(	×
134	:class_name => "MiqAlert",
135	:method_name => 'evaluate_alerts',
136	:args => [[target.class.name, target.id], raw_event, inputs]
137	) if MiqAlert.alarm_has_alerts?(raw_event)	26✔
138	end
139
140	def self.raise_evm_job_event(target, options = {}, inputs = {}, q_options = {})	1✔
141	# Eg. options = {:type => "scan", ":prefix => "request, :suffix => "abort"}
142	options.reverse_merge!(	10✔
143	:type => "scan",
144	:prefix => nil,
145	:suffix => nil
146	)
147
148	target_model = target.class.base_model.name.downcase	10✔
149	target_model = "vm" if target_model.match("template")	10✔
150
151	base_event = [target_model, options[:type]].join("_")	10✔
152	evm_event = [options[:prefix], base_event, options[:suffix]].compact.join("_")	10✔
153	raise_evm_event(target, evm_event, inputs, q_options)	10✔
154	end
155
156	def self.raise_event_for_children(target, raw_event, inputs = {})	1✔
157	child_assocs = CHILD_EVENTS.fetch_path(raw_event.to_sym, target.class.base_class.name.to_sym)	×
158	return if child_assocs.blank?	×
159
160	child_event = "#{raw_event}_parent_#{target.class.base_model.name.underscore}"	×
161	child_assocs.each do \|assoc\|	×
162	next unless target.respond_to?(assoc)	×
163	children = target.send(assoc)	×
164	children.each do \|child\|	×
165	_log.info("Raising Event [#{child_event}] for Child [(#{child.class}) #{child.name}] of Parent [(#{target.class}) #{target.name}]")	×
166	raise_evm_event_queue(child, child_event, inputs)	×
167	end
168	end
169	end
170
171	def self.event_name_for_target(target, event_suffix)	1✔
172	"#{target.class.base_model.name.underscore}_#{event_suffix}"	24✔
173	end
174
175	# return the event that triggered the policy event
176	def source_event	1✔
177	return @source_event if @source_event	×
178	return unless full_data	×
179
180	source_event_id = full_data.fetch_path(:source_event_id)	×
181	@source_event = EventStream.find_by(:id => source_event_id) if source_event_id	×
182	end
183
184	def self.display_name(number = 1)	1✔
185	n_('Event', 'Events', number)	×
186	end
187	end

ManageIQ / manageiq / 84678

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