def manage_runAllRulesets(self, REQUEST=None):
""" build current/potential matches
for devices matching all ruleset rules
"""
data = ProfileData(self.dmd)
rmvs = []
adds = []
print "building adds and removes sets"
for ruleset in self.getAllRulesets():
print "ruleset", ruleset.id
rmvs.append(set(ruleset.applyRules(True)))
adds.append(set(ruleset.applyRules(False)))
print "rebuilding components for all rulesets"
self.setRulesetComponents()
from ProfileSets import ProfileSets
setMgr = ProfileSets(self.dmd)
rmdevs = setMgr.evalSets(rmvs, False)
addevs = setMgr.evalSets(adds, False)
message = "No changes were made"
if len(rmdevs) > 0 or len(addevs) > 0:
message = ""
if len(rmdevs) > 0:
message += "Rulesets unapplied to %s" % ", ".join(data.getDeviceNames(rmdevs))
if len(addevs) > 0:
message += " Rulesets applied to %s" % ", ".join(data.getDeviceNames(addevs))
if REQUEST:
messaging.IMessageSender(self).sendToBrowser(message, message)
return self.callZenScreen(REQUEST)
def getPotentialDeviceMatches(self):
""" return list of potential member devices
complying with any or all rules in a set
"""
setMgr = ProfileSets(self.dmd)
setData = ProfileData(self.dmd)
sets = []
for rule in self.rules():
if rule.enabled == True:
dset = set(rule.rulePotentialMatches)
sets.append(dset)
devices = setMgr.evalSets(sets,self.matchAll)
return setData.getDeviceObjects(devices)
def getRuleTypes(self):
""" return list of supported rule types
"""
setData = ProfileData(self.dmd)
ruletypes = setData.getAllComponentMetaTypes()
ruletypes.sort()
ruletypes.append('Template')
ruletypes.append('Ruleset')
ruletypes.append('System')
ruletypes.append('Group')
ruletypes.append('Device')
ruletypes.append('Location')
return ruletypes
def setRuleMatches(self):
""" find potential matches for this rule:
potential matches match the rule, but are not members of all
rule organizers
"""
self.rulePotentialMatches = []
self.ruleCurrentMatches = []
setmgr = ProfileSets(self.dmd)
data = ProfileData(self.dmd)
devices = setmgr.evalRule(self)
if devices:
data.setRuleMembers(self,devices)
else:
self.rulePotentialMatches = []
self.ruleCurrentMatches = []
def getRemovableDeviceMatches(self):
""" find devices that no longer match a given ruleset
"""
currentMatches = set()
for rule in self.rules():
for d in rule.ruleCurrentMatches:
if d not in currentMatches:
currentMatches.add(d)
#currentMatches = set(self.getCurrentDeviceMatches())
self.updateMatches()
removableMatches = set(self.getCurrentDeviceMatches())
formerMatches = currentMatches.difference(removableMatches)
setData = ProfileData(self.dmd)
return setData.getDeviceObjects(formerMatches)
def manage_runRuleset(self, REQUEST=None):
""" manage memberships and template bindings
"""
data = ProfileData(self.dmd)
rmvs = self.applyRules(True)
adds = self.applyRules(False)
message = 'No changes were made'
if len(rmvs) > 0 or len(adds) > 0:
message = ''
if len(rmvs) > 0:
message += 'Ruleset unapplied to %s' % ', '.join(data.getDeviceNames(rmvs))
if len(adds) > 0:
message += ' Ruleset applied to %s' % ', '.join(data.getDeviceNames(adds))
if REQUEST:
messaging.IMessageSender(self).sendToBrowser(message,message)
return self.callZenScreen(REQUEST)
class ProfileEvents(ZenPackable):
""" Class containing routines for handling
event filters
"""
def __init__(self,dmd):
self.dmd = dmd
self.data = ProfileData(self.dmd)
def createRulesetGroup(self,ruleset):
""" create Group named after this ruleset
if it doesn't exist
"""
ruleset.rulesetGroups = []
if ruleset.id not in self.dmd.ZenUsers.getAllGroupSettingsNames():
ruleset.dmd.ZenUsers.manage_addGroup(ruleset.id)
if ruleset.id not in ruleset.rulesetGroups:
ruleset.rulesetGroups.append(ruleset.id)
def addRulesetUsersToGroups(self,ruleset):
""" add rulesetUsers to rulesetGroups
"""
for g in ruleset.rulesetGroups:
group = self.dmd.ZenUsers.getGroupSettings(g)
for u in ruleset.rulesetUsers:
if u not in group.getMemberUserIds():
user = self.dmd.ZenUsers.getUserSettings(u)
group.manage_addUsersToGroup([user.id])
def setRulesetAdminGroups(self,ruleset):
""" build Add rulesetGroups to Administrative
Roles on Group/System Organizers
"""
for rulesetGroup in ruleset.rulesetGroups:
usergroup = self.dmd.ZenUsers.getGroupSettings(rulesetGroup)
for group in ruleset.rulesetGroupOrganizers:
usergroup.manage_addAdministrativeRole(group,type='group')
usergroup.manage_editAdministrativeRoles(group,role='ZenManager',level=1)
for system in ruleset.rulesetSystemOrganizers:
usergroup.manage_addAdministrativeRole(system,type='system')
usergroup.manage_editAdministrativeRoles(system,role='ZenManager',level=1)
def createRulesetEventView(self,ruleset):
""" build the event view object for a ruleset
"""
eventWhere = self.rulesetWhere(ruleset)
ruleset.rulesetEventWhere = eventWhere
for g in ruleset.rulesetGroups:
groupSettings = self.dmd.ZenUsers.getGroupSettings(g)
eventViewName = g + '-eventview-' + ruleset.id
ids = []
for eventView in groupSettings.objectValues(spec='CustomEventView'):
ids.append(eventView.id)
if eventViewName not in ids:
groupSettings.manage_addCustomEventView(eventViewName)
for eventView in groupSettings.objectValues(spec='CustomEventView'):
if eventView.id == eventViewName:
eventView.where = eventWhere
def createRulesetAlert(self,ruleset):
""" build the alert object for a ruleset
"""
eventWhere = self.rulesetWhere(ruleset)
for g in ruleset.rulesetGroups:
alertName = g + '-ruleset-'+ruleset.id
groupSettings = self.dmd.ZenUsers.getGroupSettings(g)
ids = []
for alert in groupSettings.getActionRules():
ids.append(alert.id)
if alertName not in ids:
groupSettings.manage_addActionRule(alertName)
for alert in groupSettings.getActionRules():
if alert.id == alertName:
if len(ruleset.rulesetUsers) > 0:
alert.enabled = True
else:
alert.enabled = False
alert.where = ''
if len(ruleset.rulesetAlertWhere) > 0:
alert.where += ruleset.rulesetAlertWhere + ' and '
alert.where += eventWhere
alert.clearFormat = alert.clearFormat.replace('[zenoss]',ruleset.id)
alert.format = alert.format.replace('[zenoss]',ruleset.id)
if alertName not in ruleset.rulesetAlerts:
ruleset.rulesetAlerts.append(alertName)
def rulesetWhere(self,ruleset):
""" create where statement for ruleset
"""
# create "AND" conditions to narrow events by org membership
condition = ''
orgWheres = []
for group in ruleset.rulesetGroupOrganizers:
orgWheres.append(self.groupWhere(group))
for system in ruleset.rulesetSystemOrganizers:
orgWheres.append(self.systemWhere(system))
orgCondition = self.compoundWhere(orgWheres,"and")
# add "OR" conditions to collect events for each rule
ruleWheres = []
for rule in ruleset.rules():
if rule.enabled == True:
if rule.ruleKey != 'System' and rule.ruleKey != 'Group':
rulewhere = self.ruleWhere(rule)
ruleWheres.append(rulewhere)
if ruleset.matchAll == True:
ruleCondition = self.compoundWhere(ruleWheres,"and")
else:
ruleCondition = self.compoundWhere(ruleWheres,"or")
# join organizational and rule-based filters
if len(orgWheres) > 0 :
condition += '('+ orgCondition
if len(ruleWheres) > 0:
condition += ' and ' + ruleCondition
condition += ')'
else:
if len(ruleWheres) > 0:
condition += ruleCondition
return condition
def ruleWhere(self,rule):
""" create where statement for ruleset
"""
conditions = []
if rule.ruleKey in self.data.getAllComponentMetaTypes():
conditions.append(self.componentWhere(rule.ruleValue))
if rule.ruleEventClass != None: # if there is an event class associated w/the rule
conditions.append(self.eventClassWhere(rule.ruleEventClass))
elif rule.ruleKey == 'Template':
conditions.append(self.templateWhere(rule))
elif rule.ruleKey == 'Ruleset':
ruleset = self.dmd.Profiles.findRuleset(rule.ruleValue)
if ruleset != None:
conditions.append(self.rulesetWhere(ruleset))
elif rule.ruleKey == 'Location':
conditions.append(self.locationWhere(rule.ruleValue))
elif rule.ruleKey == 'Device':
conditions.append(self.deviceWhere(rule.ruleValue))
where = self.compoundWhere(conditions,"and")
return where
def templateWhere(self,rule):
""" create where statement for template
"""
properties = self.findTemplateProperties(rule)
conditions = []
where = ''
for property in properties:
tConds = []
eventclass,component = property
if len(eventclass) > 0:
tConds.append(self.eventClassWhere(eventclass))
if len(component) > 0:
tConds.append(self.componentWhere(component))
if len(tConds) > 0:
if len(tConds) == 1:
conditions.append(tConds[0])
else:
conditions.append(self.compoundWhere(tConds,"and"))
if len(conditions) > 0:
if len(conditions) == 1:
where = conditions[0]
else:
where = self.compoundWhere(conditions,"or")
return where
def compoundWhere(self,wheres,conjunction):
""" combine where statements
"""
condition = '('
entries = len(wheres)
for i in range(entries):
condition += wheres[i]
if i < entries-1:
condition += " " + conjunction + " "
condition += ')'
return condition
def systemWhere(self,system):
""" conditional expression for system organizer
"""
return '(systems like \'%|' + system + '%\')'
def groupWhere(self,group):
""" conditional expression for system organizer
"""
return '(deviceGroups like \'%|' + group + '%\')'
def deviceWhere(self,device):
""" conditional expression for event device
"""
return 'device like \'%' + device + '%\''
def locationWhere(self,location):
""" conditional expression for event device
"""
return 'location like \'%' + location + '%\''
def componentWhere(self,component):
""" conditional expression for event component
"""
return 'component like \'%' + component + '%\''
def eventClassWhere(self,eventclass):
""" conditional expression for event class
"""
return 'eventClass like \''+eventclass+'%\''
def findTemplateProperties(self,rule):
""" find filter-related properties for template alert
"""
properties = []
for template in self.dmd.Devices.getAllRRDTemplates():
if template.id.find(rule.ruleValue) >=0:
for ds in template.getRRDDataSources():
eventclass = ds.eventClass
component = ds.component
properties.append((eventclass,component))
return properties
def __init__(self,dmd):
self.dmd = dmd
self.data = ProfileData(self.dmd)
def getRuleCurrentMatches(self):
""" find current rule matches that are
already members of groups
"""
data = ProfileData(self.dmd)
return data.getDeviceObjects(self.ruleCurrentMatches)
def getRulePotentialMatches(self):
""" find potential matches for this rule:
"""
data = ProfileData(self.dmd)
return data.getDeviceObjects(self.rulePotentialMatches)
class ProfileSets(ZenPackable):
''' Class containing logic for evaluating rule outcomes.
'''
def __init__(self,dmd):
self.dmd = dmd
self.data = ProfileData(self.dmd)
def evalSets(self,sets,matchAll):
""" compute union or intersection of a set of sets
matchAll of True == intersection, union otherwise
"""
resultSet = None
for i in range(len(sets)):
setI = sets[i]
if resultSet == None:
resultSet = setI
for j in range(i):
setJ = sets[j]
if matchAll == True:
matchSet = setI.intersection(setJ)
resultSet = resultSet.intersection(matchSet)
else:
matchSet = setI.union(setJ)
resultSet = resultSet.union(matchSet)
return resultSet
def evalRulesets(self,rulesets,matchAll):
""" evaluate multiple rulesets
"""
sets = []
for ruleset in rulesets:
rset = self.evalRuleset(ruleset)
sets.append(rset)
return self.evalSets(sets,matchAll)
def evalRuleset(self,ruleset,easy=False):
""" evaluate all rules in a ruleset, return set of matching devices
"""
sets = [] # array containing sets of rule-matched devices
if ruleset != None:
rules = ruleset.rules()
for rule in rules:
results = []
if rule.enabled == True:
if easy == True:
results = self.evalRuleSimple(rule)
else:
results = self.evalRule(rule)
#if len(results) > 0:
sets.append(results)
if len(sets) > 0:
return self.evalSets(sets,ruleset.matchAll)
else:
"returning sets"
return sets
def evalRuleSimple(self,rule):
""" faster testing assuming that matches are already built
"""
ruleMatches = []
ruleMatches += rule.getRulePotentialMatches()
ruleMatches += rule.getRuleCurrentMatches()
return set(ruleMatches)
def evalRule(self,rule):
""" evaluate a rule, return set of matching devices
"""
if rule.ruleKey == 'Ruleset':
ruleSet = self.dmd.Profiles.findRuleset(rule.ruleValue)
return self.evalRuleset(ruleSet,easy=True)
ruleMatches = set()
for device in self.dmd.Devices.getSubDevices():
if self.data.evalRuleOnDevice(rule,device) == True:
ruleMatches.add(device)
return ruleMatches
def evalRuleComponents(self,rule,devices,getAll=True):
""" evaluate a rule, return set of matching components
"""
components = []
if rule.ruleKey != 'System' and rule.ruleKey != 'Group' and rule.ruleKey != 'Ruleset' and rule.ruleKey != 'Location' and rule.ruleKey != 'Device':
for device in devices:
components += self.data.evalRuleWithObjects(rule,device)
if rule.ruleKey == 'Ruleset':
rs = self.dmd.Profiles.findRuleset(rule.ruleValue)
if getAll == True:
components += self.getRulesetComponents(rs,devices)
else:
components += self.getRulesetFilteredComponents(rs,devices)
#print "found",len(components),"components on rule",rule.ruleKey,rule.ruleValue,"for",len(devices),"devices"
rule.ruleComponents = components
return components
def getRulesetComponents(self,ruleset,devices):
print "components on ruleset",ruleset.id,"for",len(devices),"devices"
components = []
for rule in ruleset.rules():
if rule.ruleKey != 'System' and rule.ruleKey != 'Group' and rule.ruleKey != 'Location' and rule.ruleKey != 'Device':
comps = self.evalRuleComponents(rule,devices)
components += comps
#print "found",len(components),"components"
return components
def getRulesetFilteredComponents(self,ruleset,devices):
#print "components on ruleset",ruleset.id,"for",len(devices),"devices"
componentsets = []
for rule in ruleset.rules():
if rule.ruleKey != 'System' and rule.ruleKey != 'Group' and rule.ruleKey != 'Location' and rule.ruleKey != 'Device':
comps = self.evalRuleComponents(rule,devices,False)
if len(comps) > 0:
componentsets.append(set(comps))
rulesetcomponents = self.evalSets(componentsets,ruleset.matchAll)
#print "set of rs components",len(rulesetcomponents)
if rulesetcomponents != None:
return rulesetcomponents
else:
return []
def getAllRulesets(self):
""" find all rulesets recursively
"""
data = ProfileData(self.dmd)
rulesets = data.getAllRulesets()
return rulesets
