def prepare(self):
self.url = url
hostid_filter = []
if hasattr(self, 'host_id') and self.host_id is not None:
hostid_filter = [Attribute.host_id == self.host_id]
admin_down = DBSession.query(func.count(Attribute.id)).\
filter(and_(*(
hostid_filter + [Attribute.admin_state == State.DOWN]
))).first()
self.att_total = int(admin_down[0])
db_states = DBSession.query(
EventState.internal_state, func.count(Attribute.id)).\
join(Attribute).filter(and_(
*(hostid_filter +
[Attribute.admin_state != State.DOWN]))).\
group_by(EventState.internal_state)
tmp_states = {}
for att in db_states:
tmp_states[att[0]] = att[1]
self.att_total += att[1]
self.att_states = []
for state_val, label in State.NAMES.items():
if state_val is None:
self.att_states.append((label, admin_down[0]))
else:
try:
self.att_states.append((label, tmp_states[state_val]))
except KeyError:
self.att_states.append((label, 0))
super(AttributeSummary, self).prepare()
def prepare(self):
self.url = url
hostid_filter = []
if hasattr(self, 'host_id') and self.host_id is not None:
hostid_filter = [Attribute.host_id == self.host_id]
admin_down = DBSession.query(func.count(Attribute.id)).\
filter(and_(*(
hostid_filter + [Attribute.admin_state == State.DOWN]
))).first()
self.att_total = int(admin_down[0])
db_states = DBSession.query(
EventState.internal_state, func.count(Attribute.id)).\
join(Attribute).filter(and_(
*(hostid_filter +
[Attribute.admin_state != State.DOWN]))).\
group_by(EventState.internal_state)
tmp_states = {}
for att in db_states:
tmp_states[att[0]] = att[1]
self.att_total += att[1]
self.att_states = []
for state_val, label in State.NAMES.items():
if state_val is None:
self.att_states.append((label, admin_down[0]))
else:
try:
self.att_states.append((label, tmp_states[state_val]))
except KeyError:
self.att_states.append((label, 0))
super(AttributeSummary, self).prepare()
def types_option(self, a=None):
if a is not None and type(a) is not list:
a = [a]
att_ids = [int(x) for x in a]
atype = DBSession.query(GraphType.id, GraphType.display_name,
GraphType.attribute_type_id).\
filter(GraphType.attribute_type_id.in_(
DBSession.query(Attribute.attribute_type_id).
filter(Attribute.id.in_(att_ids))
))
return dict(data_name='atype', items=atype.all())
def types_option(self, a=None):
if a is not None and type(a) is not list:
a = [a]
att_ids = [int(x) for x in a]
atype = DBSession.query(GraphType.id, GraphType.display_name,
GraphType.attribute_type_id).\
filter(GraphType.attribute_type_id.in_(
DBSession.query(Attribute.attribute_type_id).
filter(Attribute.id.in_(att_ids))
))
return dict(data_name='atype', items=atype.all())
def _delete_rows(self, del_model, del_id=None):
""" Delete all items of del_model with an ID higher than del_id
Returns number of deleted items
"""
deleted_items = 0
if del_id is None:
deleted_items = DBSession.query(del_model).delete()
else:
deleted_items = DBSession.query(del_model).\
filter(del_model.id > del_id).delete()
if deleted_items is None:
return 0
return deleted_items
def _delete_rows(self, del_model, del_id=None):
""" Delete all items of del_model with an ID higher than del_id
Returns number of deleted items
"""
deleted_items = 0
if del_id is None:
deleted_items = DBSession.query(del_model).delete()
else:
deleted_items = DBSession.query(del_model).\
filter(del_model.id > del_id).delete()
if deleted_items is None:
return 0
return deleted_items
def option(self):
""" Return a list of hosts. If user has required
permission it shows all, else just their ones """
if permissions.host_ro:
hosts = DBSession.query(Host.id, Host.display_name)
else:
hosts = DBSession.query(Host.id, Host.display_name).filter(
Host.id.in_(
DBSession.query(Attribute.host_id).filter(
Attribute.user_id ==
request.identity['user'].user_id)))
items = hosts.all()
items.insert(0, ('', '-- Choose Host --'))
return dict(items=items)
def option(self):
""" Return a list of hosts. If user has required
permission it shows all, else just their ones """
if permissions.host_ro:
hosts = DBSession.query(Host.id, Host.display_name)
else:
hosts = DBSession.query(Host.id, Host.display_name).filter(
Host.id.in_(
DBSession.query(Attribute.host_id).filter(
Attribute.user_id == request.identity['user'].user_id)
)
)
items = hosts.all()
items.insert(0, ('', '-- Choose Host --'))
return dict(items=items)
def prepare(self):
conditions = []
conditions.append(Host.show_host == True) # noqa
if self.zone_id is not None:
conditions.append(Host.zone_id == self.zone_id)
hosts = DBSession.query(Host).join(Zone).filter(
and_(*conditions)).order_by(asc(Zone.display_name),
asc(Host.display_name))
if hosts.count() == 0:
flash('No Hosts Found', 'alert')
self.map_groups = None
else:
for host in hosts:
vendor, device = host.snmp_type()
hstate, state_desc = self.host_state(host)
if self.alarmed_only and hstate == 'ok':
continue
host_fields = [('Zone', host.zone.display_name),
('Status', state_desc), ('Vendor', vendor),
('Device', device),
('Address', host.mgmt_address)]
self.add_item(
host.zone_id, host.zone.display_name, [], {
'name': host.display_name,
'state': hstate,
'url': url('/attributes/map/', {'h': host.id}),
'fields': host_fields,
})
super(HostMap, self).prepare()
def check_alarm_triggers(logger):
alarms = DBSession.query(Alarm).filter(Alarm.processed == False)
triggers = Trigger.alarm_triggers()
logger.info('%d Alarms to process', alarms.count())
if alarms.count() == 0:
return
for alarm in alarms:
for trigger in triggers:
rule_result = False
for rule in trigger.rules:
rule_result = rule.eval(rule_result, alarm)
if rule_result == True and rule.stop == True:
break
if rule_result == True:
if trigger.email_owner == True:
logger.debug('A%d T%d: email to %s', alarm.attribute.id,
trigger.id, alarm.attribute.user.user_name)
email_action(trigger, alarm.attribute.user, alarm=alarm)
if trigger.email_users == True:
sent_users = []
for trigger_user in trigger.users:
sent_users.append(alarm.attribute.user.user_name)
trigger.email_action(trigger, trigger_user, alarm=alarm)
if sent_users != []:
logger.debug('A%d T%d: email to %s', alarm.attribute.id,
trigger.id, ','.join(sent_users))
alarm.processed = True
transaction.commit()
def consolidate(self):
""" Run the consolidator for SNMP traps """
traps = DBSession.query(SnmpTrap).\
filter(SnmpTrap.processed == False) # noqa
self.logger.info('%d SNMP Traps to process', traps.count())
if traps.count() == 0:
return
for trap in traps:
trap.processed = True
try:
trap_matches = self.trap_matches[trap.trap_oid]
except KeyError:
continue
for trap_match in trap_matches:
(attribute, trap_value, error) = \
trap_match.run(trap.host, trap)
if error is not None:
self.logger.warn(
'TrapMatch error: %s',
error)
continue
if attribute is not None:
# We have matched to this trap
backend_result = \
trap_match.backend.run(None, attribute, trap_value)
self.logger.debug(
"A:%d Trap:%s -> %s:%s",
attribute.id,
str(trap_value)[:100],
trap_match.backend.display_name,
backend_result)
if trap_match.stop_if_match is True:
break
transaction.commit()
def process_events(logger):
"""
Scan all events that have not been previously checked and set alerts
where required.
Returns a set of changed attributes
"""
changed_attributes = set()
events = DBSession.query(Event).filter(Event.processed == False)
logger.info('%d Events to process', events.count())
for event in events:
if event.event_state is None or event.attribute is None:
event.set_processed()
continue
if event.event_state.is_up():
event.acknowledged = True
changed_attributes.add(event.attribute_id)
if event.event_state.is_alert() == False:
down_event = Event.find_down(event.attribute_id,
event.event_type_id,
event.id)
if event.event_state.is_downtesting():
process_event_downtesting(logger, event, down_event)
elif event.event_state.is_up():
process_event_up(logger, event, down_event)
event.set_processed()
transaction.commit()
return changed_attributes
def process_events(logger):
"""
Scan all events that have not been previously checked and set alerts
where required.
Returns a set of changed attributes
"""
changed_attributes = set()
events = DBSession.query(Event).filter(Event.processed == False)
logger.info('%d Events to process', events.count())
for event in events:
if event.event_state is None or event.attribute is None:
event.set_processed()
continue
if event.event_state.is_up():
event.acknowledged = True
changed_attributes.add(event.attribute_id)
if event.event_state.is_alert() == False:
down_event = Event.find_down(event.attribute_id,
event.event_type_id, event.id)
if event.event_state.is_downtesting():
process_event_downtesting(logger, event, down_event)
elif event.event_state.is_up():
process_event_up(logger, event, down_event)
event.set_processed()
transaction.commit()
return changed_attributes
def _get_tabledata(self, table, conditions=None, **kw):
query = DBSession.query(table)
if conditions is not None and conditions != []:
query = query.filter(and_(*conditions))
if 'sort' in kw:
insp = inspect(table)
try:
sort_col = insp.columns[kw['sort']]
except KeyError:
try:
sort_table = insp.relationships[kw['sort']]
sort_col = sort_table.table.c['display_name']
query = query.join(sort_table.table)
except KeyError:
return None
sort_order = kw.get('order') # default is asc
if sort_order == 'desc':
query = query.order_by(desc(sort_col))
else:
query = query.order_by(sort_col)
total = query.count()
if 'offset' in kw:
query = query.offset(kw['offset'])
if 'limit' in kw:
query = query.limit(kw['limit'])
return (total, query)
def consolidate(self):
""" Run the consolidator for SNMP traps """
traps = DBSession.query(SnmpTrap).\
filter(SnmpTrap.processed == False) # noqa
self.logger.info('%d SNMP Traps to process', traps.count())
if traps.count() == 0:
return
for trap in traps:
trap.processed = True
try:
trap_matches = self.trap_matches[trap.trap_oid]
except KeyError:
continue
for trap_match in trap_matches:
(attribute, trap_value, error) = \
trap_match.run(trap.host, trap)
if error is not None:
self.logger.warn('TrapMatch error: %s', error)
continue
if attribute is not None:
# We have matched to this trap
backend_result = \
trap_match.backend.run(None, attribute, trap_value)
self.logger.debug("A:%d Trap:%s -> %s:%s", attribute.id,
str(trap_value)[:100],
trap_match.backend.display_name,
backend_result)
if trap_match.stop_if_match is True:
break
transaction.commit()
def field_value(cls, attribute_id, field_tag):
""" Return the value of the field for the given attribute that
matches the tag
"""
ftag = DBSession.query(AttributeTypeField).\
join(AttributeType, Attribute).filter(
Attribute.id == attribute_id,
AttributeTypeField.tag == field_tag).first()
if ftag is None:
return None
fval = DBSession.query(cls.value).filter(
cls.attribute_id == attribute_id,
cls.attribute_type_field_id == ftag.id).first()
if fval is not None:
return fval[0]
return ftag.default_value
def mapseveritycss(self):
severities = DBSession.query(Severity)
return dict(
severities=[
(s.id, s.bgcolor,
'%.6x' % (int(s.bgcolor, 16) & 0xfefefe >> 1))
for s in severities],)
def check_alarm_triggers(logger):
alarms = DBSession.query(Alarm).filter(Alarm.processed == False)
triggers = Trigger.alarm_triggers()
logger.info('%d Alarms to process', alarms.count())
if alarms.count() == 0:
return
for alarm in alarms:
for trigger in triggers:
rule_result = False
for rule in trigger.rules:
rule_result = rule.eval(rule_result, alarm)
if rule_result == True and rule.stop == True:
break
if rule_result == True:
if trigger.email_owner == True:
logger.debug('A%d T%d: email to %s',alarm.attribute.id, trigger.id, alarm.attribute.user.user_name)
email_action(trigger, alarm.attribute.user, alarm=alarm)
if trigger.email_users == True:
sent_users = []
for trigger_user in trigger.users:
sent_users.append(alarm.attribute.user.user_name)
trigger.email_action(trigger, trigger_user,alarm=alarm)
if sent_users != [] :
logger.debug('A%d T%d: email to %s',alarm.attribute.id, trigger.id, ','.join(sent_users))
alarm.processed = True
transaction.commit()
def prepare(self):
conditions = []
conditions.append(Host.show_host == True) # noqa
if self.zone_id is not None:
conditions.append(Host.zone_id == self.zone_id)
hosts = DBSession.query(Host).join(Zone).filter(
and_(*conditions)).order_by(asc(Zone.display_name),
asc(Host.display_name))
if hosts.count() == 0:
flash('No Hosts Found', 'alert')
self.map_groups = None
else:
for host in hosts:
vendor, device = host.snmp_type()
hstate, state_desc = self.host_state(host)
if self.alarmed_only and hstate == 'ok':
continue
host_fields = [('Zone', host.zone.display_name),
('Status', state_desc),
('Vendor', vendor),
('Device', device),
('Address', host.mgmt_address)]
self.add_item(host.zone_id, host.zone.display_name,
[],
{'name': host.display_name,
'state': hstate,
'url': url('/attributes/map/', {'h': host.id}),
'fields': host_fields,
})
super(HostMap, self).prepare()
def prepare(self):
conditions = []
if self.host_id is not None:
conditions.append(Attribute.host_id == self.host_id)
if self.alarmed_only:
conditions.append(EventState.internal_state != State.UP)
attributes = DBSession.query(Attribute).join(Host, EventState).\
filter(and_(*conditions)).\
order_by(asc(Host.display_name), asc(Attribute.display_name))
if attributes.count() == 0:
flash('No Attributes Found', 'alert')
self.map_groups = None
else:
for attribute in attributes:
astate, state_desc = self.attribute_state(attribute)
try:
atype = attribute.attribute_type.display_name
except AttributeError:
atype = 'Unknown'
att_fields = [('Host', attribute.host.display_name),
('Type', atype),
('Status', state_desc), ]
for k, v in attribute.description_dict().items():
if v != '':
att_fields.append((k, v))
self.add_item(attribute.host_id, attribute.host.display_name,
[('Address', attribute.host.mgmt_address)],
{'name': attribute.display_name,
'state': astate,
'url': url('/attributes/'+str(attribute.id)),
'fields': att_fields,
})
super(AttributeMap, self).prepare()
def next_sla_analysis(cls):
"""
Return the attribute that would be the next one for SLA
Used for finding how long before we need to rescan again
"""
return DBSession.query(cls).\
filter(and_(cls.sla_id > 1, cls.poller_set_id > 1)).\
order_by(asc(cls.next_sla)).first()
def type_option(self):
""" Show option list of Attribute Types """
types = DBSession.query(
AttributeType.id,
AttributeType.display_name)
items = types.all()
items.insert(0, ('', '-- Choose Type --'))
return dict(items=items)
def alarmed_events(cls, conditions):
"""
Find all alarmed Events with extra conditions
"""
conditions.extend([
cls.alarmed == True, # noqa
cls.stop_time == None])
return DBSession.query(cls).join(EventState).filter(and_(*conditions))
def attribute_client_option(self):
""" Show option list of all users who own attributes """
users = DBSession.query(
model.User.user_id,
model.User.display_name).join(model.Attribute).distinct()
items = users.all()
items.insert(0, ('', '-- Choose Client --'))
return dict(items=items)
def _get_host_attributes(self, host_id, atype_id):
""" Return a list of Attributes for the given hosts for a given
AttributeType """
atts = DBSession.query(Attribute).filter(and_(
Attribute.host_id == host_id,
Attribute.attribute_type_id == atype_id))
if atts is None:
return {}
return {att.index: att for att in atts}
def _get_host_attributes(self):
host_atts = {}
atts = DBSession.query(Attribute).filter(
Attribute.host_id == self.dhost.id)
for att in atts:
if att.attribute_type_id not in host_atts:
host_atts[att.attribute_type_id] = {}
host_atts[att.attribute_type_id][att.index] = att
return host_atts
def _get_host_attributes(self):
host_atts = {}
atts = DBSession.query(Attribute).filter(
Attribute.host_id == self.dhost.id)
for att in atts:
if att.attribute_type_id not in host_atts:
host_atts[att.attribute_type_id] = {}
host_atts[att.attribute_type_id][att.index] = att
return host_atts
def consolidate(self):
""" Run the actual consolidation for logfiles """
logfiles = DBSession.query(Logfile)
for logfile in logfiles:
if logfile.id == 1: # Magic 1 means internal database
self._cons_syslog(logfile)
else:
self._cons_logfile(logfile)
transaction.commit()
def alarmed_events(cls, conditions):
"""
Find all alarmed Events with extra conditions
"""
conditions.extend([
cls.alarmed == True, # noqa
cls.stop_time == None
])
return DBSession.query(cls).join(EventState).filter(and_(*conditions))
def _get_host_attributes(self, host_id, atype_id):
""" Return a list of Attributes for the given hosts for a given
AttributeType """
atts = DBSession.query(Attribute).filter(
and_(Attribute.host_id == host_id,
Attribute.attribute_type_id == atype_id))
if atts is None:
return {}
return {att.index: att for att in atts}
def host_alarm(cls, host_id):
"""
Return the highest priority alarmed Event for the given Host id
"""
return cls.alarmed_events([
cls.attribute_id.in_(
DBSession.query(
Attribute.id).filter(Attribute.host_id == host_id))
]).order_by(desc(EventState.priority)).first()
def consolidate(self):
""" Run the actual consolidation for logfiles """
logfiles = DBSession.query(Logfile)
for logfile in logfiles:
if logfile.id == 1: # Magic 1 means internal database
self._cons_syslog(logfile)
else:
self._cons_logfile(logfile)
transaction.commit()
def discovered_exists(cls, host_id, attribute_type_id, index):
"""
Return True if this discovered item already exists
"""
query = DBSession.query(cls.id).filter(and_(
cls.host_id == host_id,
cls.attribute_type_id == attribute_type_id,
cls.index == index)).first()
return query is not None
def _delete_users(self):
""" Delete all items of del_model with an ID higher than del_id
Returns number of deleted items
"""
deleted_items = DBSession.query(model.User).\
filter(model.User.user_id > 2).delete()
if deleted_items is None:
return 0
return deleted_items
def host_alarm(cls, host_id):
"""
Return the highest priority alarmed Event for the given Host id
"""
return cls.alarmed_events(
[cls.attribute_id.in_(
DBSession.query(Attribute.id).
filter(Attribute.host_id == host_id))]).order_by(
desc(EventState.priority)).first()
def _delete_users(self):
""" Delete all items of del_model with an ID higher than del_id
Returns number of deleted items
"""
deleted_items = DBSession.query(model.User).\
filter(model.User.user_id > 2).delete()
if deleted_items is None:
return 0
return deleted_items
def load_config(self):
""" Load configuration for logfiles consolidation """
self.match_sets = {}
db_sets = DBSession.query(LogmatchSet)
for db_set in db_sets:
self.match_sets[db_set.id] = []
for row in db_set.rows:
self.match_sets[db_set.id].append(MatchRow(row))
self.logger.debug(
"Consolidator loaded %d match sets.\n", len(self.match_sets))
def load_config(self):
""" Load configuration for logfiles consolidation """
self.match_sets = {}
db_sets = DBSession.query(LogmatchSet)
for db_set in db_sets:
self.match_sets[db_set.id] = []
for row in db_set.rows:
self.match_sets[db_set.id].append(MatchRow(row))
self.logger.debug("Consolidator loaded %d match sets.\n",
len(self.match_sets))
def set_limit(self, limits):
from rnms.model import EventType
""" Convert the limits as tags into indexes """
fname = trigger_fields[self.field]
if fname == 'event_type':
self.limit = ','.join(
[unicode(x[0]) for x in DBSession.query(EventType.id).
filter(EventType.tag.in_(limits.split(',')))])
return
raise ValueError('Dont have limits for {}'.format(fname))
def load_config(self):
""" Load configuration from Database """
self.trap_matches = defaultdict(list)
trap_match_count = 0
for trap_match in DBSession.query(TrapMatch).\
order_by(TrapMatch.position):
trap_match_count += 1
self.trap_matches[trap_match.trap_oid].append(
MatchTrap(trap_match))
self.logger.debug("Trap Consolidator loaded %d trap rules.",
trap_match_count)
def load_config(self):
""" Load configuration from Database """
self.trap_matches = defaultdict(list)
trap_match_count = 0
for trap_match in DBSession.query(TrapMatch).\
order_by(TrapMatch.position):
trap_match_count += 1
self.trap_matches[trap_match.trap_oid].append(
MatchTrap(trap_match))
self.logger.debug("Trap Consolidator loaded %d trap rules.",
trap_match_count)
def check_all_attributes_state(logger):
""" Recalculate all Attributes Oper state
This is done when the consolidator is first started
"""
logger.debug('Recalculating all Attributes Oper state')
attributes = DBSession.query(Attribute)
if attributes is None:
return
for attribute in attributes:
attribute.calculate_oper()
transaction.commit()
def have_sla(cls, next_sla_time=None, attribute_ids=None, host_ids=None):
""" Return attributes have have a SLA set plus polling """
conditions = [cls.sla_id > 1, cls.poller_set_id > 1]
if next_sla_time is not None:
conditions.append(cls.next_sla < next_sla_time)
if attribute_ids is not None:
conditions.append(cls.id.in_(attribute_ids))
if host_ids is not None:
conditions.append(cls.host_id.in_(host_ids))
return DBSession.query(cls).options(subqueryload('sla')).\
filter(and_(*conditions))
def check_attribute_state(attribute_ids, logger):
""" Recalculate the given Attributes Oper state """
if len(attribute_ids) == 0:
return
attributes = DBSession.query(Attribute).filter(Attribute.id.in_(list(attribute_ids)))
if attributes.count() == 0:
return
logger.info('%d Attribute States to process', attributes.count())
for attribute in attributes:
attribute.calculate_oper()
transaction.commit()
def check_all_attributes_state(logger):
""" Recalculate all Attributes Oper state
This is done when the consolidator is first started
"""
logger.debug('Recalculating all Attributes Oper state')
attributes = DBSession.query(Attribute)
if attributes is None:
return
for attribute in attributes:
attribute.calculate_oper()
transaction.commit()
def _cons_syslog(self, logfile):
""" Consolidates syslog messages from database """
self.logger.info("LOGF: 1 (database)")
try:
match_set = self.match_sets[logfile.logmatchset_id]
except KeyError:
self.logger.error("LOGF(%s): MatchSet %d not found",
logfile.id, logfile.logmatchset_id)
return
lines = DBSession.query(SyslogMessage).\
filter(SyslogMessage.consolidated == False) # noqa
self._run_matches(logfile.id, match_set, lines)
def check_attribute_state(attribute_ids, logger):
""" Recalculate the given Attributes Oper state """
if len(attribute_ids) == 0:
return
attributes = DBSession.query(Attribute).filter(
Attribute.id.in_(list(attribute_ids)))
if attributes.count() == 0:
return
logger.info('%d Attribute States to process', attributes.count())
for attribute in attributes:
attribute.calculate_oper()
transaction.commit()
def _cons_syslog(self, logfile):
""" Consolidates syslog messages from database """
self.logger.info("LOGF: 1 (database)")
try:
match_set = self.match_sets[logfile.logmatchset_id]
except KeyError:
self.logger.error("LOGF(%s): MatchSet %d not found", logfile.id,
logfile.logmatchset_id)
return
lines = DBSession.query(SyslogMessage).\
filter(SyslogMessage.consolidated == False) # noqa
self._run_matches(logfile.id, match_set, lines)
def prepare(self):
conditions = []
self.graph_data = []
if self.host_id is not None:
conditions.append(Attribute.host_id == self.host_id)
for match, label in State.NAMES.items():
self.graph_data.append((label, DBSession.query(Attribute).filter(
and_(*conditions + [
Attribute.state_id == EventState.id,
EventState.internal_state == match
])).count()))
super(AttributeStateDoughnut, self).prepare()
def _run_first(self, host, trap):
"""
Return the first Attribute for given host that has the
required AttributeType. Used for where the Attribute doesn't
matter OR there is only one of this AttributeType per host.
Parameters: ignored
"""
return (DBSession.query(Attribute).filter(
and_(
Attribute.host_id == host.id,
Attribute.attribute_type_id == self._attribute_type_id,
)).first(), None)
return (None, None)
def prepare(self):
hostid_filter = []
attribute_count = 0
if self.host_id is not None:
hostid_filter = [Attribute.host_id == self.host_id]
admin_down = DBSession.query(func.count(Attribute.id)).\
filter(and_(*(
hostid_filter + [Attribute.admin_state == State.DOWN]
))).first()
attribute_count += int(admin_down[0])
db_states = DBSession.query(
EventState.internal_state, func.count(Attribute.id)).\
join(Attribute).filter(and_(
*(hostid_filter +
[Attribute.admin_state != State.DOWN]))).\
group_by(EventState.internal_state)
tmp_states = {}
for att in db_states:
tmp_states[att[0]] = att[1]
attribute_count += att[1]
self.graph_data = []
for state_val, label in State.NAMES.items():
if state_val == State.ADMIN_DOWN:
self.graph_data.append((
label.capitalize(),
0 if attribute_count == 0 else
admin_down[0]*100/attribute_count,
admin_down[0]))
else:
try:
self.graph_data.append(
(label.capitalize(),
tmp_states[state_val]*100/attribute_count,
tmp_states[state_val]))
except KeyError:
self.graph_data.append((label.capitalize(), 0, 0))
super(HBarGraph, self).prepare()
def find_down(cls, attribute, event_type):
"""
Find the first down or testing alarm of the given event_type
for this attribute.
"""
from rnms.model.event import EventState, Event
if attribute is None or event_type is None:
return None
return DBSession.query(cls).join(Event, EventState).filter(
and_(
cls.event.attribute_id == attribute.id,
cls.event.event_type_id == event_type.id,
EventState.internal_state.in_([State.DOWN, State.TESTING]),
)).order_by(desc(cls.id)).first()
def find_down(cls, attribute_id, event_type_id, exclude_event=None):
"""
Find the first down or testing alarmed Event of the given
EventType and Attribute
"""
conditions = [
cls.alarmed == True, # noqa
cls.stop_time == None,
cls.attribute_id == attribute_id,
cls.event_type_id == event_type_id,
EventState.internal_state.in_([State.DOWN, State.TESTING])
]
if exclude_event is not None:
conditions.append(cls.id != exclude_event)
return DBSession.query(cls).join(EventState).filter(
and_(*conditions)).order_by(desc(cls.id)).first()
def parse_range_max(self, attribute_id):
"""
range_max can either be the value stored in that field, or
derived from an attributes field
"""
if self.range_max_field == '':
return self.range_max
attribute_field = DBSession.query(AttributeField).filter(and_(
AttributeField.attribute_id == attribute_id,
AttributeField.attribute_type_field_id == AttributeTypeField.id,
AttributeTypeField.tag == self.range_max_field)).first()
if attribute_field is None:
return 'U'
new_max = int(attribute_field.value)
if new_max == 0:
return 'U'
return new_max
def _fill_host_table(self, host_ids):
"""
Add all or some hosts to the objects list that need
autodiscovery run on them to find attributes
"""
conditions = [Host.id > 1]
if host_ids is not None:
assert (type(host_ids) == list)
conditions.append(Host.id.in_(host_ids))
else:
conditions.append(Host.pollable == True) # noqa
hosts = DBSession.query(Host).options(
joinedload(Host.autodiscovery_policy),
joinedload(Host.ro_community)).filter(and_(*conditions))
for host in hosts:
self._waiting_hosts.append(DiscoveryHost(self, host))