7326

pending completion

Build # 7326

Build Type

push

travis-ci-com

Committed by

Fryguy

Commit Message

<a href="https://github.com/ManageIQ/manageiq-providers-vmware/commit/<a class=hub.com/ManageIQ/manageiq-providers-vmware/commit/149b666e059aad4e1afdf26f5c4d71cbaf578063">149b666e0<a href="https://github.com/ManageIQ/manageiq-providers-vmware/commit/149b666e059aad4e1afdf26f5c4d71cbaf578063">&quot;&gt;Merge pull request #753 from agrare/improve_handling_wait_for_updates_timeout

Only parse and save if there are updates

(cherry picked from commit </a><a class="double-link" href="https://github.com/ManageIQ/manageiq-providers-vmware/commit/<a class="double-link" href="https://github.com/ManageIQ/manageiq-providers-vmware/commit/2c467ab9f1cb44a7c73cc876319e770da188af08">2c467ab9f</a>">2c467ab9f</a><a href="https://github.com/ManageIQ/manageiq-providers-vmware/commit/149b666e059aad4e1afdf26f5c4d71cbaf578063">)

Run Details

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

758 of 6624 relevant lines covered (11.44%)

0.11 hits per line

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

0.0

/app/models/manageiq/providers/vmware/infra_manager/inventory/saver.rb

class ManageIQ::Providers::Vmware::InfraManager::Inventory::Saver
  include Vmdb::Logging

  def initialize(threaded: true)
    @join_limit  = 30
    @queue       = Queue.new
    @should_exit = Concurrent::AtomicBoolean.new
    @threaded    = threaded
    @thread      = nil
  end

  def start_thread
    return unless threaded

    @thread = Thread.new do
      saver_thread
      _log.info("Save inventory thread exiting")
    end

    _log.info("Save inventory thread started")
  end

  def stop_thread(wait: true)
    return unless threaded

    _log.info("Save inventory thread stopping...")

    should_exit.make_true
    queue.push(nil) # Force the blocking queue.pop call to return
    join_thread if wait
  end

  # This method will re-start the saver thread if it has crashed or terminated
  # prematurely, but is only safe to be called from a single thread.  Given
  # wait_for_updates has to be single threaded this should be fine but if you
  # intend to queue up save_inventory from multiple calling threads a mutex
  # must be added around ensure_saver_thread
  def queue_save_inventory(persister)
    _log.debug { "queueing save_inventory [#{persister.tracking_uuid}]" }

    if threaded
      ensure_saver_thread
      queue.push(persister)
    else
      save_inventory(persister)
    end
  end

  private

  attr_reader :join_limit, :queue, :should_exit, :thread, :threaded

  def saver_thread
    until should_exit.true?
      persister = queue.pop
      next if persister.nil?

      save_inventory(persister)
    end
  rescue => err
    _log.warn(err)
    _log.log_backtrace(err)
  end

  def join_thread
    return unless thread&.alive?

    unless thread.join(join_limit)
      thread.kill
    end
  end

  def ensure_saver_thread
    return if thread&.alive?

    _log.warn("Save inventory thread exited, restarting")
    start_thread
  end

  def save_inventory(persister)
    _log.debug { "running save_inventory [#{persister.tracking_uuid}]" }

    save_inventory_start_time = Time.now.utc
    persister.persist!
    update_ems_refresh_stats(persister.manager)
    post_refresh(persister.manager, save_inventory_start_time)
  rescue => err
    log_header = log_header_for_ems(persister.manager)

    _log.error("#{log_header} Save Inventory failed")
    _log.log_backtrace(err)

    update_ems_refresh_stats(persister.manager, :error => err.to_s)
  end

  def update_ems_refresh_stats(ems, error: nil)
    ems.update(:last_refresh_error => error, :last_refresh_date => Time.now.utc)
  end

  def post_refresh(ems, save_inventory_start_time)
    log_header = log_header_for_ems(ems)

    # Do any post-operations for this EMS
    post_process_refresh_classes.each do |klass|
      next unless klass.respond_to?(:post_refresh_ems)

      _log.info("#{log_header} Performing post-refresh operations for #{klass} instances...")
      klass.post_refresh_ems(ems.id, save_inventory_start_time)
      _log.info("#{log_header} Performing post-refresh operations for #{klass} instances...Complete")
    end
  end

  def post_process_refresh_classes
    [VmOrTemplate]
  end

  def log_header_for_ems(ems)
    "EMS: [#{ems.name}], id: [#{ems.id}]"
  end
end

1	class ManageIQ::Providers::Vmware::InfraManager::Inventory::Saver	×
2	include Vmdb::Logging	×
3
4	def initialize(threaded: true)	×
5	@join_limit = 30	×
6	@queue = Queue.new	×
7	@should_exit = Concurrent::AtomicBoolean.new	×
8	@threaded = threaded	×
9	@thread = nil	×
10	end	×
11
12	def start_thread	×
13	return unless threaded	×
14
15	@thread = Thread.new do	×
16	saver_thread	×
17	_log.info("Save inventory thread exiting")	×
18	end	×
19
20	_log.info("Save inventory thread started")	×
21	end	×
22
23	def stop_thread(wait: true)	×
24	return unless threaded	×
25
26	_log.info("Save inventory thread stopping...")	×
27
28	should_exit.make_true	×
29	queue.push(nil) # Force the blocking queue.pop call to return	×
30	join_thread if wait	×
31	end	×
32
33	# This method will re-start the saver thread if it has crashed or terminated
34	# prematurely, but is only safe to be called from a single thread. Given
35	# wait_for_updates has to be single threaded this should be fine but if you
36	# intend to queue up save_inventory from multiple calling threads a mutex
37	# must be added around ensure_saver_thread
38	def queue_save_inventory(persister)	×
39	_log.debug { "queueing save_inventory [#{persister.tracking_uuid}]" }	×
40
41	if threaded	×
42	ensure_saver_thread	×
43	queue.push(persister)	×
44	else	×
45	save_inventory(persister)	×
46	end	×
47	end	×
48
49	private	×
50
51	attr_reader :join_limit, :queue, :should_exit, :thread, :threaded	×
52
53	def saver_thread	×
54	until should_exit.true?	×
55	persister = queue.pop	×
56	next if persister.nil?	×
57
58	save_inventory(persister)	×
59	end	×
60	rescue => err	×
61	_log.warn(err)	×
62	_log.log_backtrace(err)	×
63	end	×
64
65	def join_thread	×
66	return unless thread&.alive?	×
67
68	unless thread.join(join_limit)	×
69	thread.kill	×
70	end	×
71	end	×
72
73	def ensure_saver_thread	×
74	return if thread&.alive?	×
75
76	_log.warn("Save inventory thread exited, restarting")	×
77	start_thread	×
78	end	×
79
80	def save_inventory(persister)	×
81	_log.debug { "running save_inventory [#{persister.tracking_uuid}]" }	×
82
83	save_inventory_start_time = Time.now.utc	×
84	persister.persist!	×
85	update_ems_refresh_stats(persister.manager)	×
86	post_refresh(persister.manager, save_inventory_start_time)	×
87	rescue => err	×
88	log_header = log_header_for_ems(persister.manager)	×
89
90	_log.error("#{log_header} Save Inventory failed")	×
91	_log.log_backtrace(err)	×
92
93	update_ems_refresh_stats(persister.manager, :error => err.to_s)	×
94	end	×
95
96	def update_ems_refresh_stats(ems, error: nil)	×
97	ems.update(:last_refresh_error => error, :last_refresh_date => Time.now.utc)	×
98	end	×
99
100	def post_refresh(ems, save_inventory_start_time)	×
101	log_header = log_header_for_ems(ems)	×
102
103	# Do any post-operations for this EMS
104	post_process_refresh_classes.each do \|klass\|	×
105	next unless klass.respond_to?(:post_refresh_ems)	×
106
107	_log.info("#{log_header} Performing post-refresh operations for #{klass} instances...")	×
108	klass.post_refresh_ems(ems.id, save_inventory_start_time)	×
109	_log.info("#{log_header} Performing post-refresh operations for #{klass} instances...Complete")	×
110	end	×
111	end	×
112
113	def post_process_refresh_classes	×
114	[VmOrTemplate]	×
115	end	×
116
117	def log_header_for_ems(ems)	×
118	"EMS: [#{ems.name}], id: [#{ems.id}]"	×
119	end	×
120	end	×

ManageIQ / manageiq-providers-vmware / 7326

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