86173

pending completion

Build # 86173

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/98554337d27d58d21a383f4fdd0fe2f666478f7e">98554337d<a href="https://github.com/ManageIQ/manageiq/commit/98554337d27d58d21a383f4fdd0fe2f666478f7e">&quot;&gt;Merge pull request #20992 from agrare/fix_miq_environment_local_ip_address

Fix MiqEnvironment.local_ip_address to not prefer loopback

(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/fd276bac67283bf050e68ecc40cf95b31c5dd16b">fd276bac6</a>">fd276bac6</a><a href="https://github.com/ManageIQ/manageiq/commit/98554337d27d58d21a383f4fdd0fe2f666478f7e">)

Run Details

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

31958 of 53556 relevant lines covered (59.67%)

208.23 hits per line

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

49.83

/app/models/miq_server.rb

require 'resolv'

class MiqServer < ApplicationRecord
  include_concern 'AtStartup'
  include_concern 'WorkerManagement'
  include_concern 'ServerMonitor'
  include_concern 'ServerSmartProxy'
  include_concern 'ConfigurationManagement'
  include_concern 'EnvironmentManagement'
  include_concern 'LogManagement'
  include_concern 'QueueManagement'
  include_concern 'RoleManagement'
  include_concern 'StatusManagement'
  include_concern 'UpdateManagement'

  include UuidMixin
  acts_as_miq_taggable
  include MiqPolicyMixin
  include RelationshipMixin

  alias_attribute :description, :name

  belongs_to              :vm, :inverse_of => :miq_server
  belongs_to              :zone
  has_many                :messages,  :as => :handler, :class_name => 'MiqQueue'
  has_many                :miq_events, :as => :target

  before_destroy          :validate_is_deleteable
  after_destroy           :destroy_linked_events_queue

  default_value_for(:name, "EVM")
  default_value_for(:zone) { Zone.default_zone }

  scope :active_miq_servers, -> { where(:status => STATUSES_ACTIVE) }
  scope :recently_active,    -> { where(:last_heartbeat => 10.minutes.ago.utc...Time.now.utc) }
  scope :with_zone_id, ->(zone_id) { where(:zone_id => zone_id) }
  virtual_delegate :description, :to => :zone, :prefix => true, :allow_nil => true, :type => :string

  validate :validate_zone_not_maintenance?
  validate :zone_unchanged_in_pods, :on => :update

  GUID_FILE = Rails.root.join("GUID").freeze

  STATUS_STARTING       = 'starting'.freeze
  STATUS_STARTED        = 'started'.freeze
  STATUS_RESTARTING     = 'restarting'.freeze
  STATUS_STOPPED        = 'stopped'.freeze
  STATUS_QUIESCE        = 'quiesce'.freeze
  STATUS_NOT_RESPONDING = 'not responding'.freeze
  STATUS_KILLED         = 'killed'.freeze

  STATUSES_STOPPED = [STATUS_STOPPED, STATUS_KILLED]
  STATUSES_ACTIVE  = [STATUS_STARTING, STATUS_STARTED]
  STATUSES_ALIVE   = STATUSES_ACTIVE + [STATUS_RESTARTING, STATUS_QUIESCE]

  RESTART_EXIT_STATUS = 123

  def validate_zone_not_maintenance?
    errors.add(:zone, N_('cannot be maintenance zone')) if zone == Zone.maintenance_zone
  end

  def hostname
    h = super
    h if h.to_s.hostname?
  end

  def starting_server_record
    self.started_on = self.last_heartbeat = Time.now.utc
    self.stopped_on = ""
    self.status     = "starting"
    self.pid        = Process.pid
    self.build      = Vmdb::Appliance.BUILD
    self.version    = Vmdb::Appliance.VERSION
    self.is_master  = false
    self.sql_spid   = ActiveRecord::Base.connection.spid
    save
  end

  def destroy_linked_events_queue
    MiqQueue.put(
      :class_name  => "MiqServer",
      :method_name => 'destroy_linked_events',
      :args        => [id],
      :zone        => my_zone
    )
  end

  def self.destroy_linked_events(server_id)
    EventStream.where(:target_id => server_id, :target_type => "MiqServer").destroy_all
  end

  def self.pidfile
    @pidfile ||= "#{Rails.root}/tmp/pids/evm.pid"
  end

  def self.running?
    p = PidFile.new(pidfile)
    p.running? ? p.pid : false
  end

  def self.seed
    unless exists?(:guid => my_guid)
      _log.info("Creating Default MiqServer with guid=[#{my_guid}], zone=[#{Zone.default_zone.name}]")
      create!(:guid => my_guid, :zone => Zone.default_zone)
      my_server_clear_cache
      ::Settings.reload! # Reload the Settings now that we have a server record
      _log.info("Creating Default MiqServer... Complete")
    end
    my_server
  end

  def validate_is_deleteable
    unless self.is_deleteable?
      _log.error(@errors.full_messages)
      throw :abort
    end
  end

  def heartbeat
    # Heartbeat the server
    t = Time.now.utc
    _log.info("Heartbeat [#{t}]...")
    reload
    self.last_heartbeat = t
    self.status = "started" if status == "not responding"
    save
    _log.info("Heartbeat [#{t}]...Complete")
  end

  def log_active_servers
    MiqRegion.my_region.active_miq_servers.sort_by { |s| [s.my_zone, s.name] }.each do |s|
      local  = s.is_local? ? 'Y' : 'N'
      master = s.is_master? ? 'Y' : 'N'
      $log.info("MiqServer: local=#{local}, master=#{master}, status=#{'%08s' % s.status}, id=#{'%05d' % s.id}, pid=#{'%05d' % s.pid}, guid=#{s.guid}, name=#{s.name}, zone=#{s.my_zone}, hostname=#{s.hostname}, ipaddress=#{s.ipaddress}, version=#{s.version}, build=#{s.build}, active roles=#{s.active_role_names.join(':')}")
    end
  end

  def stop_poll
    ::Settings.server.stop_poll.to_i_with_method
  end

  def heartbeat_frequency
    ::Settings.server.heartbeat_frequency.to_i_with_method
  end

  def server_dequeue_frequency
    ::Settings.server.server_dequeue_frequency.to_i_with_method
  end

  def server_monitor_frequency
    ::Settings.server.server_monitor_frequency.to_i_with_method
  end

  def server_log_frequency
    ::Settings.server.server_log_frequency.to_i_with_method
  end

  def worker_dequeue_frequency
    ::Settings.server.worker_dequeue_frequency.to_i_with_method
  end

  def worker_messaging_frequency
    ::Settings.server.worker_messaging_frequency.to_i_with_method
  end

  def worker_monitor_frequency
    ::Settings.server.worker_monitor_frequency.to_i_with_method
  end

  def memory_threshold
    ::Settings.server.memory_threshold.to_i_with_method
  end

  def threshold_exceeded?(name, now = Time.now.utc)
    @thresholds ||= Hash.new(1.day.ago.utc)
    exceeded = now > (@thresholds[name] + send(name))
    @thresholds[name] = now if exceeded
    exceeded
  end

  def monitor
    now = Time.now.utc
    Benchmark.realtime_block(:heartbeat)               { heartbeat }                        if threshold_exceeded?(:heartbeat_frequency, now)
    Benchmark.realtime_block(:server_dequeue)          { process_miq_queue }                if threshold_exceeded?(:server_dequeue_frequency, now)

    Benchmark.realtime_block(:server_monitor) do
      monitor_servers
      monitor_server_roles if self.is_master?
    end if threshold_exceeded?(:server_monitor_frequency, now)

    Benchmark.realtime_block(:log_active_servers)      { log_active_servers }               if threshold_exceeded?(:server_log_frequency, now)
    Benchmark.realtime_block(:worker_monitor)          { monitor_workers }                  if threshold_exceeded?(:worker_monitor_frequency, now)
    Benchmark.realtime_block(:worker_dequeue)          { populate_queue_messages }          if threshold_exceeded?(:worker_dequeue_frequency, now)
    monitor_myself
  rescue SystemExit, SignalException
    # TODO: We're rescuing Exception below. WHY? :bomb:
    # A SystemExit would be caught below, so we need to explicitly rescue/raise.
    raise
  rescue Exception => err
    _log.error(err.message)
    _log.log_backtrace(err)

    begin
      _log.info("Reconnecting to database after error...")
      # Remove the connection and establish a new one since reconnect! doesn't always play nice with SSL postgresql connections
      spec_name = ActiveRecord::Base.connection_specification_name
      ActiveRecord::Base.establish_connection(ActiveRecord::Base.remove_connection(spec_name))
    rescue Exception => err
      _log.error("#{err.message}, during reconnect!")
    else
      _log.info("Reconnecting to database after error...Successful")
    end
  end

  def monitor_myself
    if memory_usage.to_i > memory_threshold
      msg = "server(pid: #{pid}, name: #{name}) memory usage [#{memory_usage.to_i}] exceeded limit: [#{memory_threshold}].  Exiting server process."
      _log.warn(msg)

      notification_options = {
        :name             => name,
        :memory_usage     => memory_usage.to_i,
        :memory_threshold => memory_threshold,
        :pid              => pid
      }
      Notification.create(:type => "evm_server_memory_exceeded", :options => notification_options)
      shutdown_and_exit(1)
    end
  end

  def stop(sync = false)
    return if self.stopped?

    shutdown_and_exit_queue
    wait_for_stopped if sync
  end

  def wait_for_stopped
    loop do
      reload
      break if self.stopped?
      sleep stop_poll
    end
  end

  def self.stop(sync = false)
    svr = my_server(true) rescue nil
    svr.stop(sync) unless svr.nil?
    PidFile.new(pidfile).remove
  end

  def kill
    # Kill all the workers of this server
    kill_all_workers

    # Then kill this server
    _log.info("initiated for #{format_full_log_msg}")
    update(:stopped_on => Time.now.utc, :status => "killed", :is_master => false)
    (pid == Process.pid) ? shutdown_and_exit : Process.kill(9, pid)
  end

  def self.kill
    svr = my_server(true)
    svr.kill unless svr.nil?
    PidFile.new(pidfile).remove
  end

  def shutdown
    _log.info("initiated for #{format_full_log_msg}")
    MiqEvent.raise_evm_event(self, "evm_server_stop")

    quiesce
  end

  def shutdown_and_exit(exit_status = 0)
    shutdown
    exit exit_status
  end

  def quiesce
    update_attribute(:status, 'quiesce')
    deactivate_all_roles
    quiesce_all_workers
    update(:stopped_on => Time.now.utc, :status => "stopped", :is_master => false)
  end

  # Restart the local server
  def restart
    raise _("Server restart is only supported on Linux") unless MiqEnvironment::Command.is_linux?

    _log.info("Server restart initiating...")
    update_attribute(:status, "restarting")

    shutdown_and_exit(RESTART_EXIT_STATUS)
  end

  def format_full_log_msg
    "MiqServer [#{name}] with ID: [#{id}], PID: [#{pid}], GUID: [#{guid}]"
  end

  def format_short_log_msg
    "MiqServer [#{name}] with ID: [#{id}]"
  end

  def friendly_name
    _("EVM Server (%{id})") % {:id => pid}
  end

  def who_am_i
    @who_am_i ||= "#{name} #{my_zone} #{self.class.name} #{id}"
  end

  def database_application_name
    "MIQ|#{Process.pid}|#{compressed_id}|-|#{zone.compressed_id}|Server|#{zone.name}".truncate(64)
  end

  def set_database_application_name
    ArApplicationName.name = database_application_name
  end

  def is_local?
    guid == MiqServer.my_guid
  end

  def is_remote?
    !is_local?
  end

  def is_recently_active?
    last_heartbeat && (last_heartbeat >= 10.minutes.ago.utc)
  end

  def is_deleteable?
    return true if MiqEnvironment::Command.is_podified?

    if self.is_local?
      message = N_("Cannot delete currently used %{log_message}") % {:log_message => format_short_log_msg}
      @errors ||= ActiveModel::Errors.new(self)
      @errors.add(:base, message)
      return false
    end
    return true if self.stopped?

    if is_recently_active?
      message = N_("Cannot delete recently active %{log_message}") % {:log_message => format_short_log_msg}
      @errors ||= ActiveModel::Errors.new(self)
      @errors.add(:base, message)
      return false
    end

    true
  end

  def started?
    status == "started"
  end

  def stopped?
    STATUSES_STOPPED.include?(status)
  end

  def active?
    STATUSES_ACTIVE.include?(status)
  end

  def alive?
    STATUSES_ALIVE.include?(status)
  end

  def logon_status
    return :ready if self.started?
    started_on < (Time.now.utc - ::Settings.server.startup_timeout) ? :timed_out_starting : status.to_sym
  end

  def logon_status_details
    result = {:status => logon_status}
    return result if result[:status] == :ready

    wcnt = MiqWorker.find_starting.length
    workers = wcnt == 1 ? "worker" : "workers"
    message = "Waiting for #{wcnt} #{workers} to start"
    result.merge(:message => message)
  end

  #
  # Zone and Role methods
  #
  @@my_guid_mutex = Mutex.new
  def self.my_guid
    @@my_guid_mutex.synchronize { @@my_guid ||= load_or_generate_guid }
  end

  # Under normal circumstances there really shouldn't be any reason to use
  # this method. It should only be used for tests and when we need to monitor
  # multiple servers.
  def self.my_guid=(guid)
    @@my_guid_mutex.synchronize { @@my_guid = guid }
  end

  def self.load_or_generate_guid
    guid = File.read(GUID_FILE).strip if File.exist?(GUID_FILE)
    return guid if guid.present?

    SecureRandom.uuid.tap do |guid|
      _log.info("Generated MiqServer GUID #{guid}")
      File.open(GUID_FILE, "wb") do |file|
        file.sync = true
        file.write(guid)
      end
    end
  end

  cache_with_timeout(:my_server) { find_by(:guid => my_guid) }

  def self.my_zone(force_reload = false)
    my_server(force_reload).my_zone
  end

  def self.my_roles(force_reload = false)
    my_server(force_reload).my_roles
  end

  def self.my_role(force_reload = false)
    my_server(force_reload).my_role
  end

  def self.my_active_roles(force_reload = false)
    my_server(force_reload).active_role_names
  end

  def self.my_active_role(force_reload = false)
    my_server(force_reload).active_role
  end

  def self.licensed_roles(force_reload = false)
    my_server(force_reload).licensed_roles
  end

  def my_zone
    zone.name
  end

  def has_zone?(zone_name)
    my_zone == zone_name
  end

  def find_other_started_servers_in_region
    self.class.active_miq_servers.in_my_region.where.not(:id => id).to_a
  end

  def find_other_servers_in_region
    self.class.active_miq_servers.where.not(:id => id).to_a
  end

  def find_other_started_servers_in_zone
    self.class.active_miq_servers.where(:zone_id => zone_id).where.not(:id => id).to_a
  end

  def find_other_servers_in_zone
    self.class.where(:zone_id => zone_id).where.not(:id => id).to_a
  end

  def display_name
    "#{name} [#{id}]"
  end

  def server_timezone
    ::Settings.server.timezone || "UTC"
  end

  def tenant_identity
    User.super_admin
  end

  def miq_region
    MiqRegion.find_by(:region => region_id)
  end

  def self.display_name(number = 1)
    n_('Server', 'Servers', number)
  end

  def self.zone_is_modifiable?
    return false if MiqEnvironment::Command.is_podified?

    Zone.visible.in_my_region.count > 1
  end

  def self.managed_resources
    {
      :vms                     => Vm.active.count,
      :hosts                   => Host.active.count,
      :aggregate_physical_cpus => Host.active.in_my_region.sum(:aggregate_physical_cpus),
    }
  end

  def self.unmanaged_resources
    {
      :vms                     => Vm.not_active.count,
      :hosts                   => Host.archived.count,
      :aggregate_physical_cpus => Host.archived.in_my_region.sum(:aggregate_physical_cpus),
    }
  end

  def self.audit_managed_resources
    totals = managed_resources.slice(:vms, :hosts)
    $audit_log.info("Under Management: #{totals.to_json}")
  end

  private

  def zone_unchanged_in_pods
    return unless MiqEnvironment::Command.is_podified?

    errors.add(:zone, N_('cannot be changed when running in containers')) if zone_id_changed?
  end
end # class MiqServer

1	require 'resolv'	1✔
2
3	class MiqServer < ApplicationRecord	1✔
4	include_concern 'AtStartup'	1✔
5	include_concern 'WorkerManagement'	1✔
6	include_concern 'ServerMonitor'	1✔
7	include_concern 'ServerSmartProxy'	1✔
8	include_concern 'ConfigurationManagement'	1✔
9	include_concern 'EnvironmentManagement'	1✔
10	include_concern 'LogManagement'	1✔
11	include_concern 'QueueManagement'	1✔
12	include_concern 'RoleManagement'	1✔
13	include_concern 'StatusManagement'	1✔
14	include_concern 'UpdateManagement'	1✔
15
16	include UuidMixin	1✔
17	acts_as_miq_taggable	1✔
18	include MiqPolicyMixin	1✔
19	include RelationshipMixin	1✔
20
21	alias_attribute :description, :name	1✔
22
23	belongs_to :vm, :inverse_of => :miq_server	1✔
24	belongs_to :zone	1✔
25	has_many :messages, :as => :handler, :class_name => 'MiqQueue'	1✔
26	has_many :miq_events, :as => :target	1✔
27
28	before_destroy :validate_is_deleteable	1✔
29	after_destroy :destroy_linked_events_queue	1✔
30
31	default_value_for(:name, "EVM")	1✔
32	default_value_for(:zone) { Zone.default_zone }	1,608✔
33
34	scope :active_miq_servers, -> { where(:status => STATUSES_ACTIVE) }	2,094✔
35	scope :recently_active, -> { where(:last_heartbeat => 10.minutes.ago.utc...Time.now.utc) }	3✔
36	scope :with_zone_id, ->(zone_id) { where(:zone_id => zone_id) }	1✔
37	virtual_delegate :description, :to => :zone, :prefix => true, :allow_nil => true, :type => :string	1✔
38
39	validate :validate_zone_not_maintenance?	1✔
40	validate :zone_unchanged_in_pods, :on => :update	1✔
41
42	GUID_FILE = Rails.root.join("GUID").freeze	1✔
43
44	STATUS_STARTING = 'starting'.freeze	1✔
45	STATUS_STARTED = 'started'.freeze	1✔
46	STATUS_RESTARTING = 'restarting'.freeze	1✔
47	STATUS_STOPPED = 'stopped'.freeze	1✔
48	STATUS_QUIESCE = 'quiesce'.freeze	1✔
49	STATUS_NOT_RESPONDING = 'not responding'.freeze	1✔
50	STATUS_KILLED = 'killed'.freeze	1✔
51
52	STATUSES_STOPPED = [STATUS_STOPPED, STATUS_KILLED]	1✔
53	STATUSES_ACTIVE = [STATUS_STARTING, STATUS_STARTED]	1✔
54	STATUSES_ALIVE = STATUSES_ACTIVE + [STATUS_RESTARTING, STATUS_QUIESCE]	1✔
55
56	RESTART_EXIT_STATUS = 123	1✔
57
58	def validate_zone_not_maintenance?	1✔
59	errors.add(:zone, N_('cannot be maintenance zone')) if zone == Zone.maintenance_zone	1,760✔
60	end
61
62	def hostname	1✔
63	h = super	9✔
64	h if h.to_s.hostname?	9✔
65	end
66
67	def starting_server_record	1✔
68	self.started_on = self.last_heartbeat = Time.now.utc	×
69	self.stopped_on = ""	×
70	self.status = "starting"	×
71	self.pid = Process.pid	×
72	self.build = Vmdb::Appliance.BUILD	×
73	self.version = Vmdb::Appliance.VERSION	×
74	self.is_master = false	×
75	self.sql_spid = ActiveRecord::Base.connection.spid	×
76	save	×
77	end
78
79	def destroy_linked_events_queue	1✔
80	MiqQueue.put(	1✔
81	:class_name => "MiqServer",
82	:method_name => 'destroy_linked_events',
83	:args => [id],
84	:zone => my_zone
85	)
86	end
87
88	def self.destroy_linked_events(server_id)	1✔
89	EventStream.where(:target_id => server_id, :target_type => "MiqServer").destroy_all	×
90	end
91
92	def self.pidfile	1✔
93	@pidfile \|\|= "#{Rails.root}/tmp/pids/evm.pid"	×
94	end
95
96	def self.running?	1✔
97	p = PidFile.new(pidfile)	×
98	p.running? ? p.pid : false	×
99	end
100
101	def self.seed	1✔
102	unless exists?(:guid => my_guid)	×
103	_log.info("Creating Default MiqServer with guid=[#{my_guid}], zone=[#{Zone.default_zone.name}]")	×
104	create!(:guid => my_guid, :zone => Zone.default_zone)	×
105	my_server_clear_cache	×
106	::Settings.reload! # Reload the Settings now that we have a server record	×
107	_log.info("Creating Default MiqServer... Complete")	×
108	end
109	my_server	×
110	end
111
112	def validate_is_deleteable	1✔
113	unless self.is_deleteable?	1✔
114	_log.error(@errors.full_messages)	×
115	throw :abort	×
116	end
117	end
118
119	def heartbeat	1✔
120	# Heartbeat the server
121	t = Time.now.utc	×
122	_log.info("Heartbeat [#{t}]...")	×
123	reload	×
124	self.last_heartbeat = t	×
125	self.status = "started" if status == "not responding"	×
126	save	×
127	_log.info("Heartbeat [#{t}]...Complete")	×
128	end
129
130	def log_active_servers	1✔
131	MiqRegion.my_region.active_miq_servers.sort_by { \|s\| [s.my_zone, s.name] }.each do \|s\|	×
132	local = s.is_local? ? 'Y' : 'N'	×
133	master = s.is_master? ? 'Y' : 'N'	×
134	$log.info("MiqServer: local=#{local}, master=#{master}, status=#{'%08s' % s.status}, id=#{'%05d' % s.id}, pid=#{'%05d' % s.pid}, guid=#{s.guid}, name=#{s.name}, zone=#{s.my_zone}, hostname=#{s.hostname}, ipaddress=#{s.ipaddress}, version=#{s.version}, build=#{s.build}, active roles=#{s.active_role_names.join(':')}")	×
135	end
136	end
137
138	def stop_poll	1✔
139	::Settings.server.stop_poll.to_i_with_method	×
140	end
141
142	def heartbeat_frequency	1✔
143	::Settings.server.heartbeat_frequency.to_i_with_method	×
144	end
145
146	def server_dequeue_frequency	1✔
147	::Settings.server.server_dequeue_frequency.to_i_with_method	×
148	end
149
150	def server_monitor_frequency	1✔
151	::Settings.server.server_monitor_frequency.to_i_with_method	×
152	end
153
154	def server_log_frequency	1✔
155	::Settings.server.server_log_frequency.to_i_with_method	×
156	end
157
158	def worker_dequeue_frequency	1✔
159	::Settings.server.worker_dequeue_frequency.to_i_with_method	×
160	end
161
162	def worker_messaging_frequency	1✔
163	::Settings.server.worker_messaging_frequency.to_i_with_method	×
164	end
165
166	def worker_monitor_frequency	1✔
167	::Settings.server.worker_monitor_frequency.to_i_with_method	×
168	end
169
170	def memory_threshold	1✔
171	::Settings.server.memory_threshold.to_i_with_method	2✔
172	end
173
174	def threshold_exceeded?(name, now = Time.now.utc)	1✔
175	@thresholds \|\|= Hash.new(1.day.ago.utc)	×
176	exceeded = now > (@thresholds[name] + send(name))	×
177	@thresholds[name] = now if exceeded	×
178	exceeded	×
179	end
180
181	def monitor	1✔
182	now = Time.now.utc	×
183	Benchmark.realtime_block(:heartbeat) { heartbeat } if threshold_exceeded?(:heartbeat_frequency, now)	×
184	Benchmark.realtime_block(:server_dequeue) { process_miq_queue } if threshold_exceeded?(:server_dequeue_frequency, now)	×
185
186	Benchmark.realtime_block(:server_monitor) do
187	monitor_servers	×
188	monitor_server_roles if self.is_master?	×
189	end if threshold_exceeded?(:server_monitor_frequency, now)	×
190
191	Benchmark.realtime_block(:log_active_servers) { log_active_servers } if threshold_exceeded?(:server_log_frequency, now)	×
192	Benchmark.realtime_block(:worker_monitor) { monitor_workers } if threshold_exceeded?(:worker_monitor_frequency, now)	×
193	Benchmark.realtime_block(:worker_dequeue) { populate_queue_messages } if threshold_exceeded?(:worker_dequeue_frequency, now)	×
194	monitor_myself	×
195	rescue SystemExit, SignalException
196	# TODO: We're rescuing Exception below. WHY? :bomb:
197	# A SystemExit would be caught below, so we need to explicitly rescue/raise.
198	raise	×
199	rescue Exception => err
200	_log.error(err.message)	×
201	_log.log_backtrace(err)	×
202
203	begin
204	_log.info("Reconnecting to database after error...")	×
205	# Remove the connection and establish a new one since reconnect! doesn't always play nice with SSL postgresql connections
206	spec_name = ActiveRecord::Base.connection_specification_name	×
207	ActiveRecord::Base.establish_connection(ActiveRecord::Base.remove_connection(spec_name))	×
208	rescue Exception => err
209	_log.error("#{err.message}, during reconnect!")	×
210	else
211	_log.info("Reconnecting to database after error...Successful")	×
212	end
213	end
214
215	def monitor_myself	1✔
216	if memory_usage.to_i > memory_threshold	×
217	msg = "server(pid: #{pid}, name: #{name}) memory usage [#{memory_usage.to_i}] exceeded limit: [#{memory_threshold}]. Exiting server process."	×
218	_log.warn(msg)	×
219
220	notification_options = {
221	:name => name,	×
222	:memory_usage => memory_usage.to_i,
223	:memory_threshold => memory_threshold,
224	:pid => pid
225	}
226	Notification.create(:type => "evm_server_memory_exceeded", :options => notification_options)	×
227	shutdown_and_exit(1)	×
228	end
229	end
230
231	def stop(sync = false)	1✔
232	return if self.stopped?	×
233
234	shutdown_and_exit_queue	×
235	wait_for_stopped if sync	×
236	end
237
238	def wait_for_stopped	1✔
239	loop do	×
240	reload	×
241	break if self.stopped?	×
242	sleep stop_poll	×
243	end
244	end
245
246	def self.stop(sync = false)	1✔
247	svr = my_server(true) rescue nil	×
248	svr.stop(sync) unless svr.nil?	×
249	PidFile.new(pidfile).remove	×
250	end
251
252	def kill	1✔
253	# Kill all the workers of this server
254	kill_all_workers	×
255
256	# Then kill this server
257	_log.info("initiated for #{format_full_log_msg}")	×
258	update(:stopped_on => Time.now.utc, :status => "killed", :is_master => false)	×
259	(pid == Process.pid) ? shutdown_and_exit : Process.kill(9, pid)	×
260	end
261
262	def self.kill	1✔
263	svr = my_server(true)	×
264	svr.kill unless svr.nil?	×
265	PidFile.new(pidfile).remove	×
266	end
267
268	def shutdown	1✔
269	_log.info("initiated for #{format_full_log_msg}")	×
270	MiqEvent.raise_evm_event(self, "evm_server_stop")	×
271
272	quiesce	×
273	end
274
275	def shutdown_and_exit(exit_status = 0)	1✔
276	shutdown	×
277	exit exit_status	×
278	end
279
280	def quiesce	1✔
281	update_attribute(:status, 'quiesce')	×
282	deactivate_all_roles	×
283	quiesce_all_workers	×
284	update(:stopped_on => Time.now.utc, :status => "stopped", :is_master => false)	×
285	end
286
287	# Restart the local server
288	def restart	1✔
289	raise _("Server restart is only supported on Linux") unless MiqEnvironment::Command.is_linux?	×
290
291	_log.info("Server restart initiating...")	×
292	update_attribute(:status, "restarting")	×
293
294	shutdown_and_exit(RESTART_EXIT_STATUS)	×
295	end
296
297	def format_full_log_msg	1✔
298	"MiqServer [#{name}] with ID: [#{id}], PID: [#{pid}], GUID: [#{guid}]"	60✔
299	end
300
301	def format_short_log_msg	1✔
302	"MiqServer [#{name}] with ID: [#{id}]"	32✔
303	end
304
305	def friendly_name	1✔
306	_("EVM Server (%{id})") % {:id => pid}	×
307	end
308
309	def who_am_i	1✔
310	@who_am_i \|\|= "#{name} #{my_zone} #{self.class.name} #{id}"	50✔
311	end
312
313	def database_application_name	1✔
314	"MIQ\|#{Process.pid}\|#{compressed_id}\|-\|#{zone.compressed_id}\|Server\|#{zone.name}".truncate(64)	×
315	end
316
317	def set_database_application_name	1✔
318	ArApplicationName.name = database_application_name	×
319	end
320
321	def is_local?	1✔
322	guid == MiqServer.my_guid	48✔
323	end
324
325	def is_remote?	1✔
326	!is_local?	×
327	end
328
329	def is_recently_active?	1✔
330	last_heartbeat && (last_heartbeat >= 10.minutes.ago.utc)	×
331	end
332
333	def is_deleteable?	1✔
334	return true if MiqEnvironment::Command.is_podified?	1✔
335
336	if self.is_local?	×
337	message = N_("Cannot delete currently used %{log_message}") % {:log_message => format_short_log_msg}	×
338	@errors \|\|= ActiveModel::Errors.new(self)	×
339	@errors.add(:base, message)	×
340	return false	×
341	end
342	return true if self.stopped?	×
343
344	if is_recently_active?	×
345	message = N_("Cannot delete recently active %{log_message}") % {:log_message => format_short_log_msg}	×
346	@errors \|\|= ActiveModel::Errors.new(self)	×
347	@errors.add(:base, message)	×
348	return false	×
349	end
350
351	true	×
352	end
353
354	def started?	1✔
355	status == "started"	36✔
356	end
357
358	def stopped?	1✔
359	STATUSES_STOPPED.include?(status)	×
360	end
361
362	def active?	1✔
363	STATUSES_ACTIVE.include?(status)	×
364	end
365
366	def alive?	1✔
367	STATUSES_ALIVE.include?(status)	×
368	end
369
370	def logon_status	1✔
371	return :ready if self.started?	×
372	started_on < (Time.now.utc - ::Settings.server.startup_timeout) ? :timed_out_starting : status.to_sym	×
373	end
374
375	def logon_status_details	1✔
376	result = {:status => logon_status}	×
377	return result if result[:status] == :ready	×
378
379	wcnt = MiqWorker.find_starting.length	×
380	workers = wcnt == 1 ? "worker" : "workers"	×
381	message = "Waiting for #{wcnt} #{workers} to start"	×
382	result.merge(:message => message)	×
383	end
384
385	#
386	# Zone and Role methods
387	#
388	@@my_guid_mutex = Mutex.new	1✔
389	def self.my_guid	1✔
390	@@my_guid_mutex.synchronize { @@my_guid \|\|= load_or_generate_guid }	208✔
391	end
392
393	# Under normal circumstances there really shouldn't be any reason to use
394	# this method. It should only be used for tests and when we need to monitor
395	# multiple servers.
396	def self.my_guid=(guid)	1✔
397	@@my_guid_mutex.synchronize { @@my_guid = guid }	34✔
398	end
399
400	def self.load_or_generate_guid	1✔
401	guid = File.read(GUID_FILE).strip if File.exist?(GUID_FILE)	4✔
402	return guid if guid.present?	4✔
403
404	SecureRandom.uuid.tap do \|guid\|	×
405	_log.info("Generated MiqServer GUID #{guid}")	×
406	File.open(GUID_FILE, "wb") do \|file\|	×
407	file.sync = true	×
408	file.write(guid)	×
409	end
410	end
411	end
412
413	cache_with_timeout(:my_server) { find_by(:guid => my_guid) }	685✔
414
415	def self.my_zone(force_reload = false)	1✔
416	my_server(force_reload).my_zone	427✔
417	end
418
419	def self.my_roles(force_reload = false)	1✔
420	my_server(force_reload).my_roles	×
421	end
422
423	def self.my_role(force_reload = false)	1✔
424	my_server(force_reload).my_role	2✔
425	end
426
427	def self.my_active_roles(force_reload = false)	1✔
428	my_server(force_reload).active_role_names	2✔
429	end
430
431	def self.my_active_role(force_reload = false)	1✔
432	my_server(force_reload).active_role	×
433	end
434
435	def self.licensed_roles(force_reload = false)	1✔
436	my_server(force_reload).licensed_roles	×
437	end
438
439	def my_zone	1✔
440	zone.name	463✔
441	end
442
443	def has_zone?(zone_name)	1✔
444	my_zone == zone_name	×
445	end
446
447	def find_other_started_servers_in_region	1✔
448	self.class.active_miq_servers.in_my_region.where.not(:id => id).to_a	50✔
449	end
450
451	def find_other_servers_in_region	1✔
452	self.class.active_miq_servers.where.not(:id => id).to_a	×
453	end
454
455	def find_other_started_servers_in_zone	1✔
456	self.class.active_miq_servers.where(:zone_id => zone_id).where.not(:id => id).to_a	×
457	end
458
459	def find_other_servers_in_zone	1✔
460	self.class.where(:zone_id => zone_id).where.not(:id => id).to_a	×
461	end
462
463	def display_name	1✔
464	"#{name} [#{id}]"	×
465	end
466
467	def server_timezone	1✔
468	::Settings.server.timezone \|\| "UTC"	120✔
469	end
470
471	def tenant_identity	1✔
472	User.super_admin	×
473	end
474
475	def miq_region	1✔
476	MiqRegion.find_by(:region => region_id)	167✔
477	end
478
479	def self.display_name(number = 1)	1✔
480	n_('Server', 'Servers', number)	×
481	end
482
483	def self.zone_is_modifiable?	1✔
484	return false if MiqEnvironment::Command.is_podified?	×
485
486	Zone.visible.in_my_region.count > 1	×
487	end
488
489	def self.managed_resources	1✔
490	{
491	:vms => Vm.active.count,	1✔
492	:hosts => Host.active.count,
493	:aggregate_physical_cpus => Host.active.in_my_region.sum(:aggregate_physical_cpus),
494	}
495	end
496
497	def self.unmanaged_resources	1✔
498	{
499	:vms => Vm.not_active.count,	1✔
500	:hosts => Host.archived.count,
501	:aggregate_physical_cpus => Host.archived.in_my_region.sum(:aggregate_physical_cpus),
502	}
503	end
504
505	def self.audit_managed_resources	1✔
506	totals = managed_resources.slice(:vms, :hosts)	×
507	$audit_log.info("Under Management: #{totals.to_json}")	×
508	end
509
510	private	1✔
511
512	def zone_unchanged_in_pods	1✔
513	return unless MiqEnvironment::Command.is_podified?	142✔
514
515	errors.add(:zone, N_('cannot be changed when running in containers')) if zone_id_changed?	×
516	end
517	end # class MiqServer

ManageIQ / manageiq / 86173

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