Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- class AlarmsController < ApplicationController
- include Ivona::Speech
- before_filter :ensure_authenticated_user, :setup_user_scope
- respond_to :json
- def setup_user_scope()
- if current_user.is_super?
- @companies = Company.all
- @data_centers = DataCenter.includes(:data_centers_instances).all
- @instances = Instance.active_with_source
- else
- @companies = current_user.companies
- @data_centers = DataCenter.includes(:data_centers_instances).company(@companies)
- @instances = Instance.active.from_dcs(@data_centers.map(&:id)).active
- end
- end
- def index
- timestamp = Time.now
- if current_user.is_super?
- @active_alarms = Alarm.active_with_source
- @comments = AlarmComment.all
- else
- # @active_alarms = Alarm.from_instances(@instances.map(&:id)).active
- @active_alarms = Alarm.from_instances_with_source(current_user.allow_instances).active
- @comments = AlarmComment.from_instances(current_user.allow_instances) # @instances.map(&:id)
- end
- @descriptions = Dsc.all
- instance_alarms_dat = {}
- alarms_id_map = {}
- safe_comments = []
- @active_alarms.each do |alarm|
- instance_id = alarm.instance_id
- alarms_id_map[instance_id] ||= []
- alarms_id_map[instance_id].push(alarm.id)
- instance_alarms_dat[instance_id] ||= {:last_metric => nil, :last_alarm => nil}
- key = ( alarm.object == 'last_metric' ? :last_metric : :last_alarm )
- instance_alarms_dat[instance_id][key] = alarm.dat if instance_alarms_dat[instance_id][key].to_i < alarm.dat.to_i
- alarm_comments = []
- @comments.each do | comment |
- if comment.alarm_id == alarm.id
- alarm_comments.push(comment.id)
- safe_comments.push(comment)
- end
- end
- alarm.alarm_comment_ids = alarm_comments
- end
- blackout_instances = {}
- Blackout.active.each { | bo | blackout_instances[bo.up] = bo }
- active_instances = {}
- clusters = {}
- safe_instances = []
- # sql = "SELECT n, up, dat FROM (SELECT n, up, dat, rank() over (partition by up order by n desc) rnk FROM monitor.monitor) WHERE rnk = 1"
- sql = "select inst n,(select dat from monitor.monitor m where m.n=a.n) dat from (select i.n inst,(select max(m.n) n from monitor.monitor m where m.up=i.n) n from monitor.instance i where i.td>systimestamp) a"
- ldats_query = ActiveRecord::Base.connection.execute(sql)
- last_dates = {}
- while row = ldats_query.fetch do
- last_dates[row[0].to_i] = row[1]
- end
- @instances.each do |instance|
- instance.alarm_ids = alarms_id_map[instance.id]
- active_instances[instance.id] = true
- if blackout_instances.has_key?(instance.id)
- instance.is_blackout = true
- instance.blackout_dsc = blackout_instances[instance.id].dsc
- instance.blackout_fd = blackout_instances[instance.id].fd
- instance.blackout_td = blackout_instances[instance.id].td
- instance.blackout_notify = blackout_instances[instance.id].type_notify
- instance.blackout_user_id = blackout_instances[instance.id].user_id
- else
- if instance_alarms_dat.has_key?(instance.id)
- if (Time.now.to_i - instance_alarms_dat[instance.id][:last_alarm].to_i) < 30*60
- instance.last_mon_date = instance_alarms_dat[instance.id][:last_alarm]
- end
- end
- unless instance.last_mon_date
- # last_mon_date = MonitorMonitor.where(n: MonitorMonitor.select('max(n)').where(up: instance.id)).pluck(:dat)
- # instance.last_mon_date = last_mon_date[0] || Time.at(0)
- instance.last_mon_date = last_dates[instance.id.to_i] || Time.at(0)
- if instance_alarms_dat.has_key?(instance.id) && instance_alarms_dat[instance.id][:last_metric].to_i >= instance.last_mon_date.to_i
- instance.has_last_metric_alarm = true
- instance.last_metric_alarm_date = instance_alarms_dat[instance.id][:last_metric]
- end
- end
- end
- if instance.cluster_name && !instance.is_blackout
- cluster_key = "#{instance.sid}|#{instance.cluster_name}|#{instance.dbid}"
- clusters[cluster_key] = [] unless clusters.has_key?(cluster_key)
- last_mon = instance.last_mon_date || Time.at(0)
- clusters[cluster_key].push([instance.id, last_mon])
- end
- safe_instances.push(instance)
- end
- clusters.each do | key, inst |
- inst.sort! { |a,b| b[1] <=> a[1]}
- inst.slice(1, inst.length - 1).each do | el |
- safe_instances.delete_if {|item| item.id == el[0]}
- active_instances.delete(el[0])
- end
- end
- companies_info = {}
- @data_centers.each do |data_center|
- alarm_ids = []
- instance_ids = []
- data_center.data_centers_instances.each do |dc_instance|
- next unless active_instances.has_key?(dc_instance.instance_id)
- alarm_ids += alarms_id_map[dc_instance.instance_id] if alarms_id_map.has_key?(dc_instance.instance_id)
- instance_ids.push(dc_instance.instance_id)
- end
- data_center.alarm_ids = alarm_ids
- data_center.instance_ids = instance_ids
- companies_info[data_center.company_id] = {:dcs => [], :instances => [], :alarms => [], :schemes => []} unless companies_info.has_key?(data_center.company_id)
- companies_info[data_center.company_id][:dcs].push(data_center.id)
- companies_info[data_center.company_id][:instances] += instance_ids
- companies_info[data_center.company_id][:alarms] += alarm_ids
- end
- @company_schemes = CompanyScheme.company(@companies)
- @company_schemes.each do |scheme|
- companies_info[scheme.company_id] = {:dcs => [], :instances => [], :alarms => [], :schemes => []} unless companies_info.has_key?(scheme.company_id)
- companies_info[scheme.company_id][:schemes].push(scheme.id)
- end
- @companies.each do | company |
- next unless companies_info.has_key?(company.id)
- company.data_center_ids = companies_info[company.id][:dcs]
- company.instance_ids = companies_info[company.id][:instances]
- company.alarm_ids = companies_info[company.id][:alarms]
- company.company_scheme_ids = companies_info[company.id][:schemes]
- end
- # active_instances = safe_instances.collect {|item| item.id}
- ::AlarmSerializer.root = false
- ::InstanceSerializer.root = false
- ::DataCenterSerializer.root = false
- ::CompanySerializer.root = false
- ::DscSerializer.root = false
- ::CompanySchemeSerializer.root = false
- ::AlarmCommentSerializer.root = false
- logger.debug(' =========== Alarm index end ========')
- render :json => {
- :timestamp => (timestamp.to_f * 1000.0).to_i,
- :alarms => @active_alarms.map { |alarm| ::AlarmSerializer.new(alarm) },
- :instances => safe_instances.map { |instance| ::InstanceSerializer.new(instance) },
- :data_centers => @data_centers.map { |data_center| ::DataCenterSerializer.new(data_center) },
- :companies => @companies.map { |company| ::CompanySerializer.new(company) },
- :dscs => @descriptions.map { |dsc| ::DscSerializer.new(dsc) },
- :company_schemes => @company_schemes.map { |scheme| ::CompanySchemeSerializer.new(scheme) },
- :alarm_comments => safe_comments.map { |scheme| ::AlarmCommentSerializer.new(scheme) }
- }
- end
- def latest
- delta_time = 30*60
- timestamp = Time.now
- @@del_logger ||= Logger.new("#{Rails.root}/log/latest.log")
- if params[:lastUpdate].to_i > 0
- start_time = Time.at(params[:lastUpdate].to_i / 1000, params[:lastUpdate].to_i % 1000)
- if timestamp.to_i - start_time.to_i > 8*60*60
- start_time = timestamp - 8*60*60
- elsif start_time.to_i - 30 > timestamp.to_i - 30
- start_time = timestamp - 30
- end
- if current_user && current_user.is_super?
- @close = Alarm.includes(:data_centers_instance).where('EDAT >= ? AND EDAT < ?', start_time - delta_time, Time.now)
- @new = Alarm.active_with_source.where('DAT > ?', start_time - delta_time).order(rdat: :desc) # .active or N=1344639 or N=1339354
- @update = Alarm.active_with_source.where('DAT < ? AND RDAT > ?', start_time, start_time - delta_time)
- @comments = AlarmComment.where('created_at > ?', start_time - delta_time)
- else
- # @close = Alarm.includes(:data_centers_instance).company(@user_companies.pluck(:id)).where('EDAT >= ? AND EDAT < ?', start_time, Time.now)
- # @instances.map(&:id)
- @close = Alarm.from_instances_with_source(current_user.allow_instances).where('EDAT >= ? AND EDAT < ?', start_time - delta_time, Time.now)
- @new = Alarm.from_instances_with_source(current_user.allow_instances).active.where('DAT > ?', start_time - delta_time).order(rdat: :desc)
- @update = Alarm.from_instances_with_source(current_user.allow_instances).active.where('DAT < ? AND RDAT > ?', start_time, start_time - delta_time)
- @comments = AlarmComment.from_instances(current_user.allow_instances).where('created_at > ?', start_time - delta_time)
- # @new = Alarm.active_with_source.company(@user_companies.pluck(:id)).where('DAT > ?', start_time).order(rdat: :desc) # .active or N=1344639 or N=1339354
- # @update = Alarm.active_with_source.company(@user_companies.pluck(:id)).where('DAT < ? AND RDAT > ?', start_time, start_time)
- end
- # Test data
- #@new.push(create_test_alarm(:new, :warn))
- #@new.push(create_test_alarm(:new, :crit))
- #@new.push(create_test_alarm(:new, :warn))
- #@update.push(create_test_alarm(:update, :warn))
- #@close.push(create_test_alarm(:close, :crit, 1427325))
- # End test data
- # Dev log for latest data
- if @new.length > 0 || @update.length > 0 || @close.length > 0
- @@del_logger.info("[#{timestamp}] Latest for #{current_user.login} from #{request.remote_ip} time #{start_time}")
- if @new.length > 0
- @@del_logger.info(" New alarms")
- @new.each { |c| @@del_logger.info("\tn:#{c.n} warntyp:#{c.warntyp} up:#{c.up} object:'#{c.object}' val:'#{c.val}' dat:'#{c.dat}' rdat:'#{c.rdat}' edat:'#{c.edat}'") }
- end
- if @update.length > 0
- @@del_logger.info(" Updated alarms")
- @update.each { |c| @@del_logger.info("\tn:#{c.n} warntyp:#{c.warntyp} up:#{c.up} object:'#{c.object}' val:'#{c.val}' dat:'#{c.dat}' rdat:'#{c.rdat}' edat:'#{c.edat}'") }
- end
- if @close.length > 0
- @@del_logger.info(" Closed alarms")
- @close.each { |c| @@del_logger.info("\tn:#{c.n} warntyp:#{c.warntyp} up:#{c.up} object:'#{c.object}' val:'#{c.val}' dat:'#{c.dat}' rdat:'#{c.rdat}' edat:'#{c.edat}'") }
- end
- end
- alarm_comments = {}
- AlarmComment.where('created_at > ?', start_time) do | ac |
- alarm_comments[ac.alarm_id] = [] unless alarm_comments.has_key?(ac.alarm_id)
- alarm_comments[ac.alarm_id].push(ac.id)
- end
- @new.each do |alarm|
- if alarm_comments.has_key?(alarm.id)
- comments = []
- AlarmComment.where('alarm_id = ?', alarm.id) { | ac | comments.push(ac.id) }
- alarm.alarm_comment_ids = comments
- end
- if alarm.warntyp_num == 2 || alarm.warntyp_num == 3
- speech_text = (alarm.warntyp_num == 3 ? 'Critical' : 'Warning') + ' alarm on ' + alarm.instance.host + ' ' + alarm.instance.sid
- alarm.speech_url = get_speech_url(speech_text)
- end
- end
- @update.each do |alarm|
- if alarm_comments.has_key?(alarm.id)
- comments = []
- AlarmComment.where('alarm_id = ?', alarm.id) { | ac | comments.push(ac.id) }
- alarm.alarm_comment_ids = comments
- end
- end
- @instance_update = {}
- sql = "select inst n,(select dat from monitor.monitor m where m.n=a.n) dat from (select i.n inst,(select max(m.n) n from monitor.monitor m where m.up=i.n) n from monitor.instance i where i.td>systimestamp and i.n in (#{current_user.allow_instances.to_sql})) a"
- if current_user && current_user.is_super?
- sql = "select inst n,(select dat from monitor.monitor m where m.n=a.n) dat from (select i.n inst,(select max(m.n) n from monitor.monitor m where m.up=i.n) n from monitor.instance i where i.td>systimestamp) a"
- end
- ldats_query = ActiveRecord::Base.connection.execute(sql)
- while row = ldats_query.fetch do
- @instance_update[row[0].to_i] = {last_mon_date: row[1]}
- end
- # TODO: Если у инстанса нет событий статус блэкаута не изменится
- Blackout.active.each do | bo |
- next unless @instance_update.has_key?(bo.up.to_i)
- @instance_update[bo.up.to_i][:is_blackout] = true
- @instance_update[bo.up.to_i][:blackout_dsc] = bo.dsc
- @instance_update[bo.up.to_i][:blackout_fd] = bo.fd
- @instance_update[bo.up.to_i][:blackout_td] = bo.td
- @instance_update[bo.up.to_i][:blackout_notify] = bo.type_notify
- @instance_update[bo.up.to_i][:blackout_user_id] = bo.user_id
- end
- @instance_data = []
- @instance_update.each {|key,data| data[:id] = key; @instance_data.push(data)}
- ::AlarmSerializer.root = false
- ::AlarmCommentSerializer.root = false
- render :json => {
- :timestamp => (timestamp.to_f * 1000.0).to_i,
- :close => @close.map { |alarm| ::AlarmSerializer.new(alarm)},
- :new => @new.map { |alarm| ::AlarmSerializer.new(alarm)},
- :update => @update.map { |alarm| ::AlarmSerializer.new(alarm)},
- :instance_update => @instance_data,
- :comments => @comments.map { |comment| ::AlarmCommentSerializer.new(comment)}
- }
- else
- render json: {}
- end
- end
- def show
- ::AlarmSerializer.root = true
- render json: Alarm.find(params[:id])
- end
- def update
- @alarm = Alarm.find(params[:id])
- safe_params = alarm_params
- if safe_params[:close_control].to_s == 'close'
- if current_user.is_super?
- close_time = Time.now
- @alarm.update(edat: close_time)
- close_comment = CloseAlarmComment.new(comment: safe_params[:close_comment], alarm_id: @alarm.id, instance_id: @alarm.up, closed_at: close_time)
- close_comment.user = current_user
- close_comment.save
- render json: {}
- else
- render :json => {
- :errors => {blackout: 'Permission denied'}
- }, status: :unprocessable_entity
- end
- else
- render json: {}
- end
- end
- def history
- instance_id = params[:instance]
- @instance = @instances.to_a.find { |inst| inst.n == instance_id.to_i }
- return head(:unauthorized) if @instance.nil?
- where_str = ''
- where_params = {}
- logger.debug("Params 1 #{params[:alarm_id].inspect} #{params[:alarm_id].nil?}")
- if params[:alarm_id] != ''
- where_str = 'MONITOR.ALARM.N = :alarm_id'
- where_params[:alarm_id] = params[:alarm_id]
- end
- if params[:dbobject] != ''
- where_str += ' and ' if where_str.length > 0
- where_str += 'MONITOR.ALARM.OBJECT = :dbobject'
- where_params[:dbobject] = params[:dbobject]
- end
- if params[:type] != ''
- where_str += ' and ' if where_str.length > 0
- where_str += 'MONITOR.ALARM.TYPE = :type'
- where_params[:type] = params[:type]
- end
- @alarms = Alarm.closed_with_source.from_instances(@instance).where(where_str, where_params).order(edat: :desc)
- @descriptions = Dsc.all
- @comments = CloseAlarmComment.where(instance_id: @instance.id)
- comments_map = {}
- @comments.each { | comment | comments_map[comment.alarm_id] = comment }
- alarms_id_map = {}
- @alarms.each do |alarm|
- instance_id = alarm.instance_id
- alarms_id_map[instance_id] ||= []
- alarms_id_map[instance_id].push(alarm.id)
- if comments_map.has_key?(alarm.id)
- alarm.close_comment = comments_map[alarm.id].comment
- alarm.close_user_id = comments_map[alarm.id].user_id
- end
- end
- @instances.each do |instance|
- instance.alarm_ids = alarms_id_map[instance.id]
- end
- companies_info = {}
- @data_centers.each do |data_center|
- alarm_ids = []
- instance_ids = []
- data_center.data_centers_instances.each do |dc_instance|
- alarm_ids += alarms_id_map[dc_instance.instance_id] if alarms_id_map.has_key?(dc_instance.instance_id)
- instance_ids.push(dc_instance.instance_id)
- end
- data_center.alarm_ids = alarm_ids
- data_center.instance_ids = instance_ids
- companies_info[data_center.company_id] = {:dcs => [], :instances => [], :alarms => []} unless companies_info.has_key?(data_center.company_id)
- companies_info[data_center.company_id][:dcs].push(data_center.id)
- companies_info[data_center.company_id][:instances] += instance_ids
- companies_info[data_center.company_id][:alarms] += alarm_ids
- end
- @companies.each do | company |
- next unless companies_info.has_key?(company.id)
- company.data_center_ids = companies_info[company.id][:dcs]
- company.instance_ids = companies_info[company.id][:instances]
- company.alarm_ids = companies_info[company.id][:alarms]
- end
- ::AlarmHistorySerializer.root = false
- ::InstanceSerializer.root = false
- ::DataCenterSerializer.root = false
- ::CompanySerializer.root = false
- ::DscSerializer.root = false
- render :json => {
- :alarm_histories => @alarms.map { |alarm| ::AlarmHistorySerializer.new(alarm) },
- :instances => @instances.map { |instance| ::InstanceSerializer.new(instance) },
- :data_centers => @data_centers.map { |data_center| ::DataCenterSerializer.new(data_center) },
- :companies => @companies.map { |company| ::CompanySerializer.new(company) },
- :dscs => @descriptions.map { |dsc| ::DscSerializer.new(dsc) }
- }
- end
- private
- def alarm_params
- params.require(:alarm).permit(:close_control, :close_comment)
- end
- def create_test_alarm(op, level, id = nil)
- level_num = 2
- level_str = 'critical'
- if level == :warn
- level_num = 4
- level_str = 'warning'
- elsif level == :info
- level_num = 6
- level_str = 'informational'
- end
- test_instance_id = 32653
- test_dc_id = 17
- test_company_id = 1
- edat = Time.local(2999, 12, 31)
- dat = Time.now
- rdat = Time.now
- if op == :update
- dat = Time.at(dat.to_i - 30)
- rdat = Time.at(rdat.to_i - 3)
- elsif op == :close
- edat = Time.at(dat - 30)
- dat = edat
- rdat = edat
- end
- c_alarm = Alarm.new do | a |
- if op == :close
- a.n = id
- else
- a.n = Random.new.rand(2000000..3000000)
- end
- a.edat = edat
- a.rdat = rdat
- a.dat = dat
- a.up = test_instance_id
- a.type = 'test'
- a.warntyp = level_str
- a.severity_level = level_num
- a.object = "Test #{level_str} alarm"
- a.val = 'Test_test_test_test_test_test Test_test_test_test_test_test Test_test_test_test_test_test'
- a.data_centers_instance = DataCentersInstance.new do | dc |
- dc.instance_id = test_instance_id
- dc.data_center_id = test_dc_id
- dc.company_id = test_company_id
- end
- end
- c_alarm
- end
- end
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement