83301

pending completion

Build # 83301

Build Type

push

travis-ci-com

Committed by

simaishi

Commit Message

<a href="https://github.com/ManageIQ/manageiq/commit/<a class=hub.com/ManageIQ/manageiq/commit/3704d392ad6279eae417097618081142c44142a6">3704d392a<a href="https://github.com/ManageIQ/manageiq/commit/3704d392ad6279eae417097618081142c44142a6">&quot;&gt;Merge pull request #20886 from mzazrivec/invalidate_all_caches_for_ivanchuk

[IVANCHUK] Tenant changes changes miq product features on all servers

(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/f2010188db9b63e4f7f0afcad3b24565d5657d91">f2010188d</a>">f2010188d</a><a href="https://github.com/ManageIQ/manageiq/commit/3704d392ad6279eae417097618081142c44142a6">)

Run Details

7 of 7 new or added lines in 2 files covered. (100.0%)

25472 of 52766 relevant lines covered (48.27%)

86.7 hits per line

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

40.46

/app/models/miq_request_task.rb

class MiqRequestTask < ApplicationRecord
  include_concern 'Dumping'
  include_concern 'PostInstallCallback'
  include_concern 'StateMachine'

  belongs_to :miq_request
  belongs_to :source,            :polymorphic => true
  belongs_to :destination,       :polymorphic => true
  has_many   :miq_request_tasks, :dependent   => :destroy
  belongs_to :miq_request_task
  belongs_to :tenant

  serialize   :phase_context, Hash
  serialize   :options,       Hash

  default_value_for :phase_context, {}
  default_value_for :options,       {}
  default_value_for :state,         'pending'
  default_value_for :status,        'Ok'

  delegate :request_class, :task_description, :to => :class

  validates_inclusion_of :status, :in => %w( Ok Warn Error Timeout )

  include MiqRequestMixin
  include TenancyMixin

  CANCEL_STATUS_REQUESTED  = "cancel_requested".freeze
  CANCEL_STATUS_PROCESSING = "canceling".freeze
  CANCEL_STATUS_FINISHED   = "canceled".freeze
  CANCEL_STATUS            = [CANCEL_STATUS_REQUESTED, CANCEL_STATUS_PROCESSING, CANCEL_STATUS_FINISHED].freeze

  validates :cancelation_status, :inclusion => { :in        => CANCEL_STATUS,
                                                 :allow_nil => true,
                                                 :message   => "should be one of #{CANCEL_STATUS.join(", ")}" }

  def approved?
    if miq_request.class.name.include?('Template') && miq_request_task
      miq_request_task.miq_request.approved?
    else
      miq_request.approved?
    end
  end

  def after_request_task_create
  end

  def update_and_notify_parent(upd_attr)
    upd_attr[:message] = upd_attr[:message][0, 255] if upd_attr.key?(:message)
    update_attributes!(upd_attr)

    # If this request has a miq_request_task parent use that, otherwise the parent is the miq_request
    parent = miq_request_task || miq_request
    parent.reload
    parent.update_request_status
  end

  def update_request_status
    states = Hash.new { |h, k| h[k] = 0 }
    status = Hash.new { |h, k| h[k] = 0 }

    child_requests = miq_request_tasks
    task_count = child_requests.size
    child_requests.each do |child_req|
      states[child_req.state] += 1
      states[:total] += 1
      status[child_req.status] += 1
    end
    total = states.delete(:total).to_i
    unknown_state = task_count - total
    states["unknown"] = unknown_state unless unknown_state.zero?
    msg = states.sort.collect { |s| "#{s[0].capitalize} = #{s[1]}" }.join("; ")

    req_state = (states.length == 1) ? states.keys.first : "active"

    # Determine status to report
    req_status = status.slice('Error', 'Timeout', 'Warn').keys.first || 'Ok'

    if req_state == "finished" && state != "finished"
      req_state = req_status == 'Ok' ? completed_state : "finished"
      $log.info("Child tasks finished but current task still processing. Setting state to: [#{req_state}]...")
    end

    if req_state == "finished"
      msg = (req_status == 'Ok') ? "Task complete" : "Task completed with errors"
    end

    # If there is only 1 request_task, set the parent message the same
    if task_count == 1
      child = child_requests.first
      msg = child.message unless child.nil?
    end

    update_and_notify_parent(:state => req_state, :status => req_status, :message => display_message(msg))
  end

  def completed_state
    "provisioned"
  end

  def execute_callback(state, message, _result)
    unless state.to_s.downcase == "ok"
      update_and_notify_parent(:state => "finished", :status => "Error", :message => "Error: #{message}")
    end
  end

  def self.request_class
    if self <= MiqProvision
      MiqProvisionRequest
    else
      name.underscore.gsub(/_task$/, "_request").camelize.constantize
    end
  end

  def self.task_description
    request_class::TASK_DESCRIPTION
  end

  def get_description
    self.class.get_description(self)
  end

  def task_check_on_delivery
    if request_class::ACTIVE_STATES.include?(state)
      raise _("%{task} request is already being processed") % {:task => request_class::TASK_DESCRIPTION}
    end
    task_check_on_execute
  end

  def task_check_on_execute
    if state == "finished"
      raise _("%{task} request has already been processed") % {:task => request_class::TASK_DESCRIPTION}
    end
    raise _("approval is required for %{task}") % {:task => request_class::TASK_DESCRIPTION} unless approved?
  end

  def deliver_to_automate(req_type = request_type, zone = nil)
    task_check_on_delivery

    _log.info("Queuing #{request_class::TASK_DESCRIPTION}: [#{description}]...")

    if self.class::AUTOMATE_DRIVES
      args = {
        :object_type   => self.class.name,
        :object_id     => id,
        :attrs         => {"request" => req_type},
        :instance_name => "AUTOMATION",
        :user_id       => get_user.id,
        :miq_group_id  => get_user.current_group.id,
        :tenant_id     => get_user.current_tenant.id,
      }

      zone ||= source.respond_to?(:my_zone) ? source.my_zone : MiqServer.my_zone
      MiqQueue.put(
        :class_name     => 'MiqAeEngine',
        :method_name    => 'deliver',
        :args           => [args],
        :role           => 'automate',
        :zone           => options.fetch(:miq_zone, zone),
        :tracking_label => tracking_label_id,
      )
      update_and_notify_parent(:state => "pending", :status => "Ok",  :message => "Automation Starting")
    else
      execute_queue
    end
  end

  def execute_queue(queue_options = {})
    task_check_on_execute

    _log.info("Queuing #{request_class::TASK_DESCRIPTION}: [#{description}]...")

    deliver_on = nil
    if get_option(:schedule_type) == "schedule"
      deliver_on = get_option(:schedule_time).utc rescue nil
    end

    zone = source.respond_to?(:my_zone) ? source.my_zone : MiqServer.my_zone

    queue_options.reverse_merge!(
      :class_name     => self.class.name,
      :instance_id    => id,
      :method_name    => "execute",
      :zone           => options.fetch(:miq_zone, zone),
      :role           => miq_request.my_role,
      :tracking_label => tracking_label_id,
      :deliver_on     => deliver_on,
      :miq_callback   => {:class_name => self.class.name, :instance_id => id, :method_name => :execute_callback}
    )
    MiqQueue.put(queue_options)

    update_and_notify_parent(:state => "queued", :status => "Ok", :message => "State Machine Initializing")
  end

  def execute
    _log.info("Executing #{request_class::TASK_DESCRIPTION} request: [#{description}]")
    update_and_notify_parent(:state => "active", :status => "Ok", :message => "In Process")

    begin
      message = "#{request_class::TASK_DESCRIPTION} initiated"
      _log.info(message)
      update_and_notify_parent(:message => message)

      # Process the request
      do_request

    rescue => err
      message = "Error: #{err.message}"
      _log.error("[#{message}] encountered during #{request_class::TASK_DESCRIPTION}")
      _log.log_backtrace(err)
      update_and_notify_parent(:state => "finished", :status => "Error", :message => message)
      return
    end
  end

  def self.display_name(number = 1)
    n_('Request Task', 'Request Tasks', number)
  end

  def cancel
    raise _("Cancel operation is not supported for %{class}") % {:class => self.class.name}
  end

  def cancel_requested?
    cancelation_status == MiqRequestTask::CANCEL_STATUS_REQUESTED
  end

  def canceling?
    cancelation_status == MiqRequestTask::CANCEL_STATUS_PROCESSING
  end

  def canceled?
    cancelation_status == MiqRequestTask::CANCEL_STATUS_FINISHED
  end

  private

  def validate_request_type
    errors.add(:request_type, "should be #{request_class.request_types.join(", ")}") unless request_class.request_types.include?(request_type)
  end

  def validate_state
    errors.add(:state, "should be #{valid_states.join(", ")}") unless valid_states.include?(state)
  end

  def valid_states
    %w(pending finished) + request_class::ACTIVE_STATES
  end
end

1	class MiqRequestTask < ApplicationRecord	1✔
2	include_concern 'Dumping'	1✔
3	include_concern 'PostInstallCallback'	1✔
4	include_concern 'StateMachine'	1✔
5
6	belongs_to :miq_request	1✔
7	belongs_to :source, :polymorphic => true	1✔
8	belongs_to :destination, :polymorphic => true	1✔
9	has_many :miq_request_tasks, :dependent => :destroy	1✔
10	belongs_to :miq_request_task	1✔
11	belongs_to :tenant	1✔
12
13	serialize :phase_context, Hash	1✔
14	serialize :options, Hash	1✔
15
16	default_value_for :phase_context, {}	1✔
17	default_value_for :options, {}	1✔
18	default_value_for :state, 'pending'	1✔
19	default_value_for :status, 'Ok'	1✔
20
21	delegate :request_class, :task_description, :to => :class	1✔
22
23	validates_inclusion_of :status, :in => %w( Ok Warn Error Timeout )	1✔
24
25	include MiqRequestMixin	1✔
26	include TenancyMixin	1✔
27
28	CANCEL_STATUS_REQUESTED = "cancel_requested".freeze	1✔
29	CANCEL_STATUS_PROCESSING = "canceling".freeze	1✔
30	CANCEL_STATUS_FINISHED = "canceled".freeze	1✔
31	CANCEL_STATUS = [CANCEL_STATUS_REQUESTED, CANCEL_STATUS_PROCESSING, CANCEL_STATUS_FINISHED].freeze	1✔
32
33	validates :cancelation_status, :inclusion => { :in => CANCEL_STATUS,	1✔
34	:allow_nil => true,
35	:message => "should be one of #{CANCEL_STATUS.join(", ")}" }
36
37	def approved?	1✔
38	if miq_request.class.name.include?('Template') && miq_request_task	×
39	miq_request_task.miq_request.approved?	×
40	else
41	miq_request.approved?	×
42	end
43	end
44
45	def after_request_task_create	1✔
46	end
47
48	def update_and_notify_parent(upd_attr)	1✔
49	upd_attr[:message] = upd_attr[:message][0, 255] if upd_attr.key?(:message)	×
50	update_attributes!(upd_attr)	×
51
52	# If this request has a miq_request_task parent use that, otherwise the parent is the miq_request
53	parent = miq_request_task \|\| miq_request	×
54	parent.reload	×
55	parent.update_request_status	×
56	end
57
58	def update_request_status	1✔
59	states = Hash.new { \|h, k\| h[k] = 0 }	×
60	status = Hash.new { \|h, k\| h[k] = 0 }	×
61
62	child_requests = miq_request_tasks	×
63	task_count = child_requests.size	×
64	child_requests.each do \|child_req\|	×
65	states[child_req.state] += 1	×
66	states[:total] += 1	×
67	status[child_req.status] += 1	×
68	end
69	total = states.delete(:total).to_i	×
70	unknown_state = task_count - total	×
71	states["unknown"] = unknown_state unless unknown_state.zero?	×
72	msg = states.sort.collect { \|s\| "#{s[0].capitalize} = #{s[1]}" }.join("; ")	×
73
74	req_state = (states.length == 1) ? states.keys.first : "active"	×
75
76	# Determine status to report
77	req_status = status.slice('Error', 'Timeout', 'Warn').keys.first \|\| 'Ok'	×
78
79	if req_state == "finished" && state != "finished"	×
80	req_state = req_status == 'Ok' ? completed_state : "finished"	×
81	$log.info("Child tasks finished but current task still processing. Setting state to: [#{req_state}]...")	×
82	end
83
84	if req_state == "finished"	×
85	msg = (req_status == 'Ok') ? "Task complete" : "Task completed with errors"	×
86	end
87
88	# If there is only 1 request_task, set the parent message the same
89	if task_count == 1	×
90	child = child_requests.first	×
91	msg = child.message unless child.nil?	×
92	end
93
94	update_and_notify_parent(:state => req_state, :status => req_status, :message => display_message(msg))	×
95	end
96
97	def completed_state	1✔
98	"provisioned"	×
99	end
100
101	def execute_callback(state, message, _result)	1✔
102	unless state.to_s.downcase == "ok"	×
103	update_and_notify_parent(:state => "finished", :status => "Error", :message => "Error: #{message}")	×
104	end
105	end
106
107	def self.request_class	1✔
108	if self <= MiqProvision	78✔
109	MiqProvisionRequest	×
110	else
111	name.underscore.gsub(/_task$/, "_request").camelize.constantize	78✔
112	end
113	end
114
115	def self.task_description	1✔
116	request_class::TASK_DESCRIPTION	×
117	end
118
119	def get_description	1✔
120	self.class.get_description(self)	×
121	end
122
123	def task_check_on_delivery	1✔
124	if request_class::ACTIVE_STATES.include?(state)	×
125	raise _("%{task} request is already being processed") % {:task => request_class::TASK_DESCRIPTION}	×
126	end
127	task_check_on_execute	×
128	end
129
130	def task_check_on_execute	1✔
131	if state == "finished"	×
132	raise _("%{task} request has already been processed") % {:task => request_class::TASK_DESCRIPTION}	×
133	end
134	raise _("approval is required for %{task}") % {:task => request_class::TASK_DESCRIPTION} unless approved?	×
135	end
136
137	def deliver_to_automate(req_type = request_type, zone = nil)	1✔
138	task_check_on_delivery	×
139
140	_log.info("Queuing #{request_class::TASK_DESCRIPTION}: [#{description}]...")	×
141
142	if self.class::AUTOMATE_DRIVES	×
143	args = {	×
144	:object_type => self.class.name,
145	:object_id => id,
146	:attrs => {"request" => req_type},
147	:instance_name => "AUTOMATION",
148	:user_id => get_user.id,
149	:miq_group_id => get_user.current_group.id,
150	:tenant_id => get_user.current_tenant.id,
151	}
152
153	zone \|\|= source.respond_to?(:my_zone) ? source.my_zone : MiqServer.my_zone	×
154	MiqQueue.put(	×
155	:class_name => 'MiqAeEngine',
156	:method_name => 'deliver',
157	:args => [args],
158	:role => 'automate',
159	:zone => options.fetch(:miq_zone, zone),
160	:tracking_label => tracking_label_id,
161	)
162	update_and_notify_parent(:state => "pending", :status => "Ok", :message => "Automation Starting")	×
163	else
164	execute_queue	×
165	end
166	end
167
168	def execute_queue(queue_options = {})	1✔
169	task_check_on_execute	×
170
171	_log.info("Queuing #{request_class::TASK_DESCRIPTION}: [#{description}]...")	×
172
173	deliver_on = nil	×
174	if get_option(:schedule_type) == "schedule"	×
175	deliver_on = get_option(:schedule_time).utc rescue nil	×
176	end
177
178	zone = source.respond_to?(:my_zone) ? source.my_zone : MiqServer.my_zone	×
179
180	queue_options.reverse_merge!(	×
181	:class_name => self.class.name,
182	:instance_id => id,
183	:method_name => "execute",
184	:zone => options.fetch(:miq_zone, zone),
185	:role => miq_request.my_role,
186	:tracking_label => tracking_label_id,
187	:deliver_on => deliver_on,
188	:miq_callback => {:class_name => self.class.name, :instance_id => id, :method_name => :execute_callback}
189	)
190	MiqQueue.put(queue_options)	×
191
192	update_and_notify_parent(:state => "queued", :status => "Ok", :message => "State Machine Initializing")	×
193	end
194
195	def execute	1✔
196	_log.info("Executing #{request_class::TASK_DESCRIPTION} request: [#{description}]")	×
197	update_and_notify_parent(:state => "active", :status => "Ok", :message => "In Process")	×
198
199	begin	×
200	message = "#{request_class::TASK_DESCRIPTION} initiated"	×
201	_log.info(message)	×
202	update_and_notify_parent(:message => message)	×
203
204	# Process the request
205	do_request	×
206
207	rescue => err	×
208	message = "Error: #{err.message}"	×
209	_log.error("[#{message}] encountered during #{request_class::TASK_DESCRIPTION}")	×
210	_log.log_backtrace(err)	×
211	update_and_notify_parent(:state => "finished", :status => "Error", :message => message)	×
212	return	×
213	end
214	end
215
216	def self.display_name(number = 1)	1✔
217	n_('Request Task', 'Request Tasks', number)	×
218	end
219
220	def cancel	1✔
221	raise _("Cancel operation is not supported for %{class}") % {:class => self.class.name}	×
222	end
223
224	def cancel_requested?	1✔
225	cancelation_status == MiqRequestTask::CANCEL_STATUS_REQUESTED	×
226	end
227
228	def canceling?	1✔
229	cancelation_status == MiqRequestTask::CANCEL_STATUS_PROCESSING	×
230	end
231
232	def canceled?	1✔
233	cancelation_status == MiqRequestTask::CANCEL_STATUS_FINISHED	×
234	end
235
236	private	1✔
237
238	def validate_request_type	1✔
239	errors.add(:request_type, "should be #{request_class.request_types.join(", ")}") unless request_class.request_types.include?(request_type)	36✔
240	end
241
242	def validate_state	1✔
243	errors.add(:state, "should be #{valid_states.join(", ")}") unless valid_states.include?(state)	36✔
244	end
245
246	def valid_states	1✔
247	%w(pending finished) + request_class::ACTIVE_STATES	36✔
248	end
249	end

ManageIQ / manageiq / 83301

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