def load_device(self, dmd, access_id, secret,
path='', windowspath=''):
getFacade('aws', dmd).configure(
access_id, secret, path, windowspath)
commit()
mgrPath = '/zport/dmd/Devices/AWS/EC2/devices/EC2Manager'
mgr = dmd.restrictedTraverse(mgrPath)
mgr.collectDevice()
def __init__(self, *args, **kwargs):
super(supportPoller, self).__init__(*args, **kwargs)
self.deviceFacade = getFacade('device', self.dmd)
self.zport = self.dmd.zport
self.sync = self.zport._p_jar.sync
self.log = logging.getLogger("zen.GoVanguard.Support.Poller")
self.cycleNumber = 0
def load(self, configData):
"""
configData is a JSON dict that contains a key of the same
name as specified in this class (ie self.key).
The value from this key is expected to be an arrary of dictionaries
as used by the ZEP system. See the documentation in the
ZenModel/ZenPackTemplate/CONTENT/zep/zep.json.example file.
"""
if configData:
self.zep = getFacade('zep')
items = configData.get(EventDetailItemHandler.key)
if items is None:
log.warn(
"Expected key '%s' for details is missing from the zep.json file",
self.key)
return
detailItemSet = from_dict(
EventDetailItemSet,
dict(
# An empty array in details casues ZEP to puke
details=items))
try:
self.zep.addIndexedDetails(detailItemSet)
except Exception as ex:
log.error(
"ZEP %s error adding detailItemSet data: %s\nconfigData= %s",
getattr(ex, 'status', 'unknown'), detailItemSet,
configData)
log.error("See the ZEP logs for more information.")
def add_threshold(dmd, device_class, template, id_, cfg):
tf = getFacade('template', dmd)
# This is weird, the catalog is making us look up the datapoints at the
# deviceclass level
points = []
allpoints = [(ds._object.name(), ds)
for ds in tf.getDataSources(device_class.uid)]
# Handle a single datapoint
if isinstance(cfg['dataPoints'], str):
cfg['dataPoints'] = [cfg['dataPoints']]
for dp in cfg['dataPoints']:
for item in allpoints:
if item[0] == dp:
points.append(item[1].uid)
tf.addThreshold(template.uid, cfg['type'], id_, points)
threshold = [
t for t in tf.getThresholds(template.uid + '/thresholds/' + id_)
][0]
# Apply cfg items directly to threshold attributes.
for k, v in cfg.items():
if k not in ('dataPoints', 'type'):
setattr(threshold, k, v)
def add_datapoint(dmd, datasource, id_, cfg):
tf = getFacade('template', dmd)
datapoint = tf.addDataPoint(datasource.uid, str(id_))
# http://jira.zenoss.com/jira/browse/ZEN-5017
datapoint = ZuulInfo(datapoint)
# Handle cfg shortcuts like DERIVE_MIN_0 and GAUGE_MIN_0_MAX_100.
if isinstance(cfg, types.StringTypes):
if 'DERIVE' in cfg.upper():
datapoint.rrdtype = 'DERIVE'
min_match = re.search(r'MIN_(\d+)', cfg, re.IGNORECASE)
if min_match:
datapoint.rrdmin = min_match.group(1)
max_match = re.search(r'MAX_(\d+)', cfg, re.IGNORECASE)
if max_match:
datapoint.rrdmax = max_match.group(1)
else:
# Apply cfg items directly to datasource attributes.
for k, v in cfg.items():
if k not in ('aliases'):
setattr(datapoint, k, v)
if 'aliases' in cfg:
add_aliases(dmd, datapoint, cfg['aliases'])
def getIpAddresses(self, limit=0, start=0, sort='ipAddressAsInt', dir='DESC',
params=None, uid=None, criteria=()):
infos = []
cat = ICatalogTool(self._getObject(uid))
reverse = dir=='DESC'
brains = cat.search("Products.ZenModel.IpAddress.IpAddress",
start=start, limit=limit,
orderby=sort, reverse=reverse)
for brain in brains:
infos.append(IInfo(unbrain(brain)))
devuuids = set(info.device.uuid for info in infos if info.device)
# get ping severities
zep = getFacade('zep')
pingSeverities = zep.getEventSeverities(devuuids,
severities=(),
status=(),
eventClass=Status_Ping)
self._assignPingStatuses(infos, pingSeverities)
# get snmp severities
snmpSeverities = zep.getEventSeverities(devuuids,
severities=(),
status=(),
eventClass=Status_Snmp)
self._assignSnmpStatuses(infos, snmpSeverities)
return SearchResults(infos, brains.total, brains.hash_)
def __init__(self):
"""
create object and and coonect to the db
"""
ZenScriptBase.__init__(self, connect=True)
self.log = logging.getLogger("EventModder")
self.api = getFacade("event")
def getComponentTree(self, uid):
from Products.ZenEvents.EventManagerBase import EventManagerBase
componentTypes = {}
uuidMap = {}
dev = self._getObject(uid)
for brain in dev.componentSearch():
uuidMap[brain.getUUID] = brain.meta_type
compType = componentTypes.setdefault(brain.meta_type, { 'count' : 0, 'severity' : 0 })
compType['count'] += 1
# Do one big lookup of component events and merge back in to type later
if not uuidMap:
return []
zep = getFacade('zep')
showSeverityIcon = self.context.dmd.UserInterfaceSettings.getInterfaceSettings().get('showEventSeverityIcons')
if showSeverityIcon:
severities = zep.getWorstSeverity(uuidMap.keys())
for uuid, sev in severities.iteritems():
compType = componentTypes[uuidMap[uuid]]
compType['severity'] = max(compType['severity'], sev)
result = []
for name, compType in componentTypes.iteritems():
result.append({
'type' : name,
'count' : compType['count'],
'severity' : EventManagerBase.severities.get(compType['severity'], 0).lower()
})
return result
def getDeviceDashboard(self):
"""return device info for bad device to dashboard"""
zep = getFacade('zep')
manager = IGUIDManager(self.context.dmd)
deviceSeverities = zep.getDeviceIssuesDict()
zem = self.context.dmd.ZenEventManager
devdata = []
for uuid in deviceSeverities.keys():
dev = manager.getObject(uuid)
if dev and isinstance(dev, Device):
if (not zem.checkRemotePerm(ZEN_VIEW, dev)
or dev.productionState < zem.prodStateDashboardThresh
or dev.priority < zem.priorityDashboardThresh):
continue
alink = dev.getPrettyLink()
try:
severities = deviceSeverities[uuid]
severities = dict((zep.getSeverityName(sev).lower(), counts) for (sev, counts) in severities.iteritems())
pill = getEventPillME(dev, severities=severities)
except ServiceException:
continue
evts = [alink,pill]
devdata.append((evts, severities))
devdata.sort(key=lambda x:(x[1]['critical'], x[1]['error'], x[1]['warning']), reverse=True)
return [x[0] for x in devdata[:100]]
def load(self, configData):
"""
configData is a JSON dict that contains a key of the same
name as specified in this class (ie self.key).
The value from this key is expected to be an arrary of dictionaries
as used by the ZEP system. See the documentation in the
ZenModel/ZenPackTemplate/CONTENT/zep/zep.json.example file.
"""
if configData:
self.zep = getFacade('zep')
items = configData.get(EventDetailItemHandler.key)
if items is None:
log.warn("Expected key '%s' for details is missing from the zep.json file",
self.key)
return
detailItemSet = from_dict(EventDetailItemSet, dict(
# An empty array in details casues ZEP to puke
details = items
))
try:
self.zep.addIndexedDetails(detailItemSet)
except Exception as ex:
log.error("ZEP %s error adding detailItemSet data: %s\nconfigData= %s",
getattr(ex, 'status', 'unknown'), detailItemSet, configData)
log.error("See the ZEP logs for more information.")
def getRRDValues(self,
dsnames,
start=None,
end=None,
function="LAST",
format="%.2lf",
extraRpn="",
cf="AVERAGE"):
"""
Return a dict of key value pairs where dsnames are the keys.
"""
try:
fac = getFacade('metric', self.dmd)
return fac.getValues(self,
dsnames,
start=start,
end=end,
format=format,
extraRpn=extraRpn,
cf=cf)
except Exception:
log.exception("Unable to collect metric values for %s",
self.getPrimaryId())
# couldn't get any metrics return an empty dictionary
return {}
def getDevices(self, uid=None, start=0, limit=50, sort='name', dir='ASC',
params=None, hashcheck=None):
params = params if params else {}
# Passing a key that's not an index in the catalog will
# cause a serious performance penalty. Remove 'status' from
# the 'params' parameter before passing it on.
statuses = params.pop('status', None)
brains = self.getDeviceBrains(uid, start, limit, sort, dir, params,
hashcheck)
# ZEN-10057 - Handle the case of empty results for a filter with no matches
if not brains:
return SearchResults(iter([]), 0, '0')
devices = [ IInfo(obj) for obj in imap(unbrain, brains) if obj ]
if statuses is not None and len(statuses) < 3:
devices = [d for d in devices if d.status in statuses]
uuids = set(dev.uuid for dev in devices)
if uuids:
zep = getFacade('zep', self._dmd)
severities = zep.getEventSeverities(uuids)
for device in devices:
device.setEventSeverities(severities[device.uuid])
return SearchResults(iter(devices), brains.total, brains.hash_)
def load_device(self,
dmd,
deviceName,
username,
api_key,
project_id,
user_domain_name,
project_domain_name,
auth_url,
ceilometer_url=None,
region_name=None,
collector='localhost'):
# we accept, but do not use, the ceilometer_url parameter for backwards
# compatability reasons.
return getFacade('openstackinfrastructure',
dmd).addOpenStack(deviceName,
username,
api_key,
project_id,
user_domain_name,
project_domain_name,
auth_url,
region_name=region_name,
collector=collector)
def _verifyZepRunning(self):
zep = getFacade('zep')
try:
zep.getConfig()
return True
except ServiceException:
return False
def snippet(self):
last_path_item = self.request['PATH_INFO'].split('/')[-1]
archive = last_path_item.lower().find('history') != -1 or last_path_item.lower().find('archive') != -1
result = ["Ext.onReady(function(){"]
defs = column_config(self.request, archive=archive)
reader_fields = reader_config(archive=archive)
result.append('Zenoss.env.COLUMN_DEFINITIONS=[')
result.append(',\n'.join(defs))
result.append('];')
result.append('Zenoss.env.READER_DEFINITIONS=[')
result.append(',\n'.join(reader_fields))
result.append('];')
result.append('Zenoss.env.ZP_DETAILS=[')
try:
zepdetails = getFacade('zep').getUnmappedDetails()
zpdetails = []
for detail in zepdetails:
if detail['type'] in (EventDetailItem.STRING, EventDetailItem.IP_ADDRESS, EventDetailItem.PATH):
rulecmp = 'Zenoss.form.rule.STRINGCOMPARISONS'
else:
rulecmp = 'Zenoss.form.rule.NUMBERCOMPARISONS'
zpdetails.append("{{ text: _t('{name}'), value: '{key}', comparisons: {cmp} }}".format(name=detail['name'], key=detail['key'], cmp=rulecmp))
result.append(',\n'.join(zpdetails))
except ZepConnectionError, e:
log.error(e.message)
def getIpAddresses(self, limit=0, start=0, sort='ipAddressAsInt', dir='DESC',
params=None, uid=None, criteria=()):
infos = []
cat = ICatalogTool(self._getObject(uid))
reverse = dir=='DESC'
brains = cat.search("Products.ZenModel.IpAddress.IpAddress",
start=start, limit=limit,
orderby=sort, reverse=reverse)
for brain in brains:
infos.append(IInfo(unbrain(brain)))
devuuids = set(info.device.uuid for info in infos if info.device)
# get ping severities
zep = getFacade('zep')
pingSeverities = zep.getEventSeverities(devuuids,
severities=(),
status=(),
eventClass=Status_Ping)
self._assignPingStatuses(infos, pingSeverities)
# get snmp severities
snmpSeverities = zep.getEventSeverities(devuuids,
severities=(),
status=(),
eventClass=Status_Snmp)
self._assignSnmpStatuses(infos, snmpSeverities)
return SearchResults(infos, brains.total, brains.hash_)
def event_count(self):
zep = getFacade('zep')
try:
yield "Event Count", zep.countEventsSince(time.time() -
24 * 60 * 60)
except ZepConnectionError:
yield "Event Count: last 24hr", "Not Available"
def snippet(self):
last_path_item = self.request['PATH_INFO'].split('/')[-1]
archive = last_path_item.lower().find('history') != -1 or last_path_item.lower().find('archive') != -1
result = ["Ext.onReady(function(){"]
defs = column_config(self.request, archive=archive)
reader_fields = reader_config(archive=archive)
result.append('Zenoss.env.COLUMN_DEFINITIONS=[')
result.append(',\n'.join(defs))
result.append('];')
result.append('Zenoss.env.READER_DEFINITIONS=[')
result.append(',\n'.join(reader_fields))
result.append('];')
result.append('Zenoss.env.ZP_DETAILS=[')
try:
zepdetails = getFacade('zep').getUnmappedDetails()
zpdetails = []
for detail in zepdetails:
if detail['type'] in (EventDetailItem.STRING, EventDetailItem.IP_ADDRESS, EventDetailItem.PATH):
rulecmp = 'Zenoss.form.rule.STRINGCOMPARISONS'
else:
rulecmp = 'Zenoss.form.rule.NUMBERCOMPARISONS'
zpdetails.append("{{ text: _t('{name}'), value: '{key}', comparisons: {cmp} }}".format(name=detail['name'], key=detail['key'], cmp=rulecmp))
result.append(',\n'.join(zpdetails))
result.append('];')
except ZepConnectionError, e:
log.error(e.message)
def add_datapoint(dmd, datasource, id_, cfg):
tf = getFacade('template', dmd)
datapoint = tf.addDataPoint(datasource.uid, str(id_))
# http://jira.zenoss.com/jira/browse/ZEN-5017
datapoint = ZuulInfo(datapoint)
# Handle cfg shortcuts like DERIVE_MIN_0 and GAUGE_MIN_0_MAX_100.
if isinstance(cfg, types.StringTypes):
if 'DERIVE' in cfg.upper():
datapoint.rrdtype = 'DERIVE'
min_match = re.search(r'MIN_(\d+)', cfg, re.IGNORECASE)
if min_match:
datapoint.rrdmin = min_match.group(1)
max_match = re.search(r'MAX_(\d+)', cfg, re.IGNORECASE)
if max_match:
datapoint.rrdmax = max_match.group(1)
else:
# Apply cfg items directly to datasource attributes.
for k, v in cfg.items():
if k not in ('aliases'):
setattr(datapoint, k, v)
if 'aliases' in cfg:
add_aliases(dmd, datapoint, cfg['aliases'])
def pingDevices(self, evids):
"""Ping devices associated with evids."""
if not evids:
return DirectResponse.succeed(msg="No events selected.")
# Gather unique devices.
devices = {}
zep = getFacade('zep')
evt_filter = zep.createEventFilter(uuid=evids)
evt_summaries = zep.getEventSummaries(offset=0, filter=evt_filter)
for evt_summary in evt_summaries.get('events', []):
device_id = evt_summary['occurrence'][0]['actor']['element_identifier']
if device_id in devices:
continue
device = self.context.dmd.Devices.findDeviceByIdExact(device_id)
if not device or not device.getManageIp():
continue
devices[device_id] = device
# Run ping for each unique device.
ping_output = {}
for device_id, device in devices.iteritems():
ping_output[device_id] = subprocess.check_output(
"ping -c3 {} ; exit 0".format(device.getManageIp()),
stderr=subprocess.STDOUT,
shell=True)
return DirectResponse.succeed(data=ping_output)
def event_count(self):
zep = getFacade('zep', self.dmd)
try:
yield ("Event Count",
zep.countEventsSince(time.time() - 24 * 60 * 60))
except ZepConnectionError:
yield "Event Count: last 24hr", "Not Available"
def getComponentTree(self, uid):
from Products.ZenEvents.EventManagerBase import EventManagerBase
componentTypes = {}
uuidMap = {}
dev = self._getObject(uid)
for brain in dev.componentSearch():
uuidMap[brain.getUUID] = brain.meta_type
compType = componentTypes.setdefault(brain.meta_type, { 'count' : 0, 'severity' : 0 })
compType['count'] += 1
# Do one big lookup of component events and merge back in to type later
if not uuidMap:
return []
zep = getFacade('zep')
showSeverityIcon = self.context.dmd.UserInterfaceSettings.getInterfaceSettings().get('showEventSeverityIcons')
if showSeverityIcon:
severities = zep.getWorstSeverity(uuidMap.keys())
for uuid, sev in severities.iteritems():
compType = componentTypes[uuidMap[uuid]]
compType['severity'] = max(compType['severity'], sev)
result = []
for name, compType in componentTypes.iteritems():
result.append({
'type' : name,
'count' : compType['count'],
'severity' : EventManagerBase.severities.get(compType['severity'], 0).lower()
})
return result
def pingDevices(self, evids):
"""Ping devices associated with evids."""
if not evids:
return DirectResponse.succeed(msg="No events selected.")
# Gather unique devices.
devices = {}
zep = getFacade('zep')
evt_filter = zep.createEventFilter(uuid=evids)
evt_summaries = zep.getEventSummaries(offset=0, filter=evt_filter)
for evt_summary in evt_summaries.get('events', []):
device_id = evt_summary['occurrence'][0]['actor'][
'element_identifier']
if device_id in devices:
continue
device = self.context.dmd.Devices.findDeviceByIdExact(device_id)
if not device or not device.getManageIp():
continue
devices[device_id] = device
# Run ping for each unique device.
ping_output = {}
for device_id, device in devices.iteritems():
ping_output[device_id] = subprocess.check_output(
"ping -c3 {} ; exit 0".format(device.getManageIp()),
stderr=subprocess.STDOUT,
shell=True)
return DirectResponse.succeed(data=ping_output)
def bulkLoadMetricData(self, infos):
"""
If the info objects have the attribute dataPointsToFetch we
will load all the datapoints in one metric service query
instead of one per info object
"""
if len(infos) == 0:
return
datapoints = set()
indexedInfos = dict()
for info in infos:
indexedInfos[info._object.getResourceKey()] = info
if hasattr(info, "dataPointsToFetch"):
[datapoints.add(dp) for dp in info.dataPointsToFetch]
# in case no metrics were asked for
if len(datapoints) == 0:
return
# get the metric facade
mfacade = getFacade('metric', self._dmd)
# metric facade expects zenmodel objects or uids
results = mfacade.getMultiValues([i._object for i in infos],
datapoints,
returnSet="LAST")
# assign the metrics to the info objects
for resourceKey, record in results.iteritems():
if indexedInfos.get(resourceKey) is not None:
info = indexedInfos[resourceKey]
for key, val in record.iteritems():
info.setBulkLoadProperty(key, val)
def getComponentTree(self, uid):
from Products.ZenEvents.EventManagerBase import EventManagerBase
componentTypes, uuidMap = self._get_component_types_from_zcatalog(uid)
# Do one big lookup of component events and merge back in to type later
if not uuidMap:
return []
zep = getFacade('zep')
showSeverityIcon = self.context.dmd.UserInterfaceSettings.getInterfaceSettings(
).get('showEventSeverityIcons')
if showSeverityIcon:
severities = zep.getWorstSeverity(uuidMap.keys())
for uuid, sev in severities.iteritems():
compType = componentTypes[uuidMap[uuid]]
compType['severity'] = max(compType['severity'], sev)
result = []
for name, compType in componentTypes.iteritems():
result.append({
'type':
name,
'count':
compType['count'],
'severity':
EventManagerBase.severities.get(compType['severity'],
0).lower()
})
return result
def _loadSeverity(self):
if self._severity is None:
if self.uuid:
zep = getFacade('zep')
sev = zep.getSeverityName(zep.getWorstSeverity([self.uuid]).get(self.uuid, 0)).lower()
self._severity = sev
return self._severity
def bulkLoadMetricData(self, infos):
"""
If the info objects have the attribute dataPointsToFetch we
will load all the datapoints in one metric service query
instead of one per info object
"""
if len(infos) == 0:
return
datapoints = set()
indexedInfos = dict()
for info in infos:
indexedInfos[info._object.getResourceKey()] = info
if hasattr(info, "dataPointsToFetch"):
[datapoints.add(dp) for dp in info.dataPointsToFetch]
# in case no metrics were asked for
if len(datapoints) == 0:
return
# get the metric facade
mfacade = getFacade('metric', self._dmd)
# metric facade expects zenmodel objects or uids
results = mfacade.getMultiValues([i._object for i in infos], datapoints, returnSet="LAST")
# assign the metrics to the info objects
for resourceKey, record in results.iteritems():
if indexedInfos.get(resourceKey) is not None:
info = indexedInfos[resourceKey]
for key, val in record.iteritems():
info.setBulkLoadProperty(key, val)
def getDevices(self,
uid=None,
start=0,
limit=50,
sort='name',
dir='ASC',
params=None,
hashcheck=None):
params = params if params else {}
# Passing a key that's not an index in the catalog will
# cause a serious performance penalty. Remove 'status' from
# the 'params' parameter before passing it on.
statuses = params.pop('status', None)
brains = self.getDeviceBrains(uid, start, limit, sort, dir, params,
hashcheck)
# ZEN-10057 - Handle the case of empty results for a filter with no matches
if not brains:
return SearchResults(iter([]), 0, '0')
devices = [IInfo(obj) for obj in imap(unbrain, brains) if obj]
if statuses is not None and len(statuses) < 3:
devices = [d for d in devices if d.status in statuses]
uuids = set(dev.uuid for dev in devices)
if uuids:
zep = getFacade('zep', self._dmd)
severities = zep.getEventSeverities(uuids)
for device in devices:
device.setEventSeverities(severities[device.uuid])
return SearchResults(iter(devices), brains.total, brains.hash_)
def _verifyZepRunning(self):
zep = getFacade('zep')
try:
zep.getConfig()
return True
except ServiceException:
return False
def stream(self):
data = unjson(self.request.get('data'))
uids = data['uids']
facade = getFacade('device', self.context)
for deviceOrganizer in imap(facade._getObject, uids):
deviceOrganizer.runDeviceMonitor(REQUEST=self.request,
write=self.write)
def getDeviceDashboard(self):
"""return device info for bad device to dashboard"""
zep = getFacade('zep')
manager = IGUIDManager(self.context.dmd)
deviceSeverities = zep.getDeviceIssuesDict()
zem = self.context.dmd.ZenEventManager
devdata = []
for uuid in deviceSeverities.keys():
dev = manager.getObject(uuid)
if dev and isinstance(dev, Device):
if (not zem.checkRemotePerm(ZEN_VIEW, dev)
or dev.productionState < zem.prodStateDashboardThresh
or dev.priority < zem.priorityDashboardThresh):
continue
alink = dev.getPrettyLink()
try:
severities = deviceSeverities[uuid]
severities = dict(
(zep.getSeverityName(sev).lower(), counts)
for (sev, counts) in severities.iteritems())
pill = getEventPillME(dev, severities=severities)
except ServiceException:
continue
evts = [alink, pill]
devdata.append((evts, severities))
devdata.sort(key=lambda x:
(x[1]['critical'], x[1]['error'], x[1]['warning']),
reverse=True)
return [x[0] for x in devdata[:100]]
def add_graphpoint(dmd, device_class, template, graph, id_, cfg):
tf = getFacade('template', dmd)
if cfg['type'] == 'Threshold':
threshold = [
t for t in tf.getThresholds(template.uid) if t.name == id_
][0]
tf.addThresholdToGraph(graph.uid, threshold.uid)
graphpoints = []
for gp in tf.getGraphPoints(graph.uid):
if isinstance(gp, ThresholdGraphPointInfo) and gp.id == id_:
graphpoint = gp
break
elif cfg['type'] == 'DataPoint':
# this is all sorts of messed up getDataSources returns datapoints if the context is a device class
# there isnt a getDataPoints call
# the name of a datapoint appears to be a datasource.datapoint but the id path appears better
# We are just splitting that and probably making some sort of bad
# assumption here.
datapoints = [
dp for dp in tf.getDataSources(device_class.uid)
if dp._object.name() == cfg['dpName'] and template.uid in dp.uid
]
for datapoint in datapoints:
tf.addDataPointToGraph(datapoint.uid, graph.uid)
# Normally we would try to find the created graphpoint by UID, but since we don't know that
# we will find all graphpoints with the datapoint name. If there are more than one,
# we're in trouble.
graphpoints = []
for gp in tf.getGraphPoints(graph.uid):
if isinstance(
gp,
DataPointGraphPointInfo) and gp.dpName == cfg['dpName']:
graphpoints.append(gp)
if len(graphpoints) != 1:
# don't really know what to do here.. really, the only option is to delete the
# pre-existing ones and hope there's only one in the json, but for now i'm leaving
# that as an exercise to the user.
print "Error: Expected to find one graphpoint, but found %d instead." % len(
graphpoints)
return
graphpoint = graphpoints[0]
else:
print "GraphPoint of %s is not supported yet." % cfg['type']
return
# Apply cfg items directly to graph attributes.
for k, v in cfg.items():
if k not in ('type'):
if k == 'description':
graphpoint.setDescription(v)
else:
setattr(graphpoint, k, v)
# Fix the graphpoint name/ID. addDataPointToGraph sets it to a default value, but the
# import file may have a different one specified.
if graphpoint.id != id_:
fix_id(graphpoint, id_)
def save_return_payload(self, returnPayload):
'''
Process and save the data returned from the callhome server. This
always includes versioning and crypto key changes, and may include
other data to be processed by plugins to the IReturnPayloadProcessor
interface.
'''
try:
returnPayload = zlib.decompress(
base64.urlsafe_b64decode(returnPayload))
returnPayload = json.loads(returnPayload)
except:
logger.debug('Error decoding return payload from server')
return
if all(x in returnPayload
for x in ('currentPublicKey', 'revocationList')):
# TODO: VERIFY revocation list, and apply
newPubkey = returnPayload.get('currentPublicKey')
if self.callHome.publicKey != newPubkey:
self.callHome.publicKey = newPubkey
if 'encrypted' in returnPayload:
base64data = base64.urlsafe_b64decode(
str(returnPayload.get('encrypted')))
data = json.loads(decrypt(base64data, self.callHome.symmetricKey))
if 'compliancereport' in data:
data['compliancereport']['pdf'] = base64.urlsafe_b64decode(
str(data['compliancereport']['pdf']))
if 'latestVersion' in data:
# Save the latest version, and send a
# message if new version available
self.dmd.lastVersionCheck = long(time.time())
available = Version.parse('Zenoss ' + data['latestVersion'])
if (getattr(self.dmd, 'availableVersion', '') !=
available.short()):
self.dmd.availableVersion = available.short()
if self.dmd.About.getZenossVersion() < available:
try:
import socket
zep = getFacade('zep')
summary = (
'A new version of Zenoss (%s)' +
'has been released') % available.short()
zep.create(summary, 'Info', socket.getfqdn())
except ZepConnectionError:
logger.warning("ZEP not running - can't send " +
"new version event")
# Go through other data in the return payload, and process
for name, utility in getUtilitiesFor(IReturnPayloadProcessor):
if name in data:
utility.process(self.dmd, data[name])
self.callHome.lastSuccess = long(time.time())
self.chs.updateStat('lastSuccess', long(time.time()))
return
def remote_getDeviceIssues(self, *args, **kwargs):
zep = getFacade('zep')
try:
return zep.getDeviceIssues()
except ServiceConnectionError, e:
# ZEN-503: Don't print a traceback in this case
log.warn("Unable to contact ZEP.")
return None
def remote_getDeviceIssues(self, *args, **kwargs):
zep = getFacade('zep')
try:
return zep.getDeviceIssues()
except ServiceConnectionError, e:
# ZEN-503: Don't print a traceback in this case
log.warn("Unable to contact ZEP.")
return None
def _deleteDevice(self, uid, deleteEvents=True):
facade = getFacade('device')
try:
result = facade.deleteDevices([uid], deleteEvents=deleteEvents)
except Exception as e:
result = "Unable to device device {0}. {1}".format(uid, e.message)
return result
def getEventSeverities(self):
if self._eventSeverities is None:
zep = getFacade('zep')
# ZEP facade returns CRITICAL/ERROR/WARNING by default - need to include INFO for rainbow on
# device detail page.
severities = (SEVERITY_CRITICAL, SEVERITY_ERROR, SEVERITY_WARNING, SEVERITY_INFO)
self.setEventSeverities(zep.getEventSeveritiesByUuid(self.uuid, severities=severities))
return self._eventSeverities
def list(self, configData):
if configData:
self.zep = getFacade('zep')
items = configData.get(EventDetailItemHandler.key, [])
info = []
for item in items:
info.append("Would be adding the following detail to be indexed by ZEP: %s" % item.key)
return info
def __init__(self, dmd, twokeydict):
a, b = twokeydict.items()
aid, self.abrains = a
bid, self.bbrains = b
self.a = dmd.unrestrictedTraverse(aid)
self.b = dmd.unrestrictedTraverse(bid)
self.zep = getFacade('zep', dmd)
self.idmgr = Manager(dmd)
def testOrganizer(self):
devices = self.dmd.Devices
dc = devices.createOrganizer('/Test')
self.assert_(dc in devices.children())
self.assert_(dc in devices.getSubOrganizers())
self.assertEqual(devices.countChildren(), 6)
self.assert_('Test' in devices.childIds())
self.assert_('/Test' in devices.getOrganizerNames())
self.assertEqual(devices.getOrganizer('/Test'), dc)
layer = devices.createOrganizer('/Layer')
devices.moveOrganizer('Layer',['Test'])
self.assert_('/Layer' in devices.getOrganizerNames())
self.assert_(dc not in devices.children())
self.assert_(dc in devices.getSubOrganizers())
getFacade('device', self.dmd).deleteNode('/zport/dmd/Devices/Layer')
self.assert_(layer not in devices.children())
self.assert_(dc not in devices.getSubOrganizers())
def testOrganizer(self):
devices = self.dmd.Devices
dc = devices.createOrganizer('/Test')
self.assert_(dc in devices.children())
self.assert_(dc in devices.getSubOrganizers())
self.assertEqual(devices.countChildren(), 6)
self.assert_('Test' in devices.childIds())
self.assert_('/Test' in devices.getOrganizerNames())
self.assertEqual(devices.getOrganizer('/Test'), dc)
layer = devices.createOrganizer('/Layer')
devices.moveOrganizer('Layer',['Test'])
self.assert_('/Layer' in devices.getOrganizerNames())
self.assert_(dc not in devices.children())
self.assert_(dc in devices.getSubOrganizers())
getFacade('device', self.dmd).deleteNode('/zport/dmd/Devices/Layer')
self.assert_(layer not in devices.children())
self.assert_(dc not in devices.getSubOrganizers())
def remote_getStatus(self):
"""Return devices with Mail problems."""
zep = getFacade('zep')
issues = zep.getDeviceIssues(eventClass=[Status_Mail],
severity=[SEVERITY_WARNING, SEVERITY_ERROR, SEVERITY_CRITICAL])
return [d
for d, count, total in issues
if getattr(self.config.devices, d, None)]
def stream(self):
data = unjson(self.request.get('data'))
uids = data['uids']
facade = getFacade('device', self.context)
for device in imap(facade._getObject, uids):
device.collectDevice(REQUEST=self.request,
write=self.write,
debug=True)
def upgrade(self, configData):
if configData:
self.zep = getFacade('zep')
items = configData.get(EventDetailItemHandler.key, [])
for item in items:
log.info("Upgrading the following to be indexed by ZEP: %s" % item)
detailItem = from_dict(EventDetailItem, item)
self.zep.updateIndexedDetailItem(detailItem)
def testOrganizer(self):
devices = self.dmd.Devices
dc = devices.createOrganizer("/Test")
self.assert_(dc in devices.children())
self.assert_(dc in devices.getSubOrganizers())
self.assertEqual(devices.countChildren(), 6)
self.assert_("Test" in devices.childIds())
self.assert_("/Test" in devices.getOrganizerNames())
self.assertEqual(devices.getOrganizer("/Test"), dc)
layer = devices.createOrganizer("/Layer")
devices.moveOrganizer("Layer", ["Test"])
self.assert_("/Layer" in devices.getOrganizerNames())
self.assert_(dc not in devices.children())
self.assert_(dc in devices.getSubOrganizers())
getFacade("device", self.dmd).deleteNode("/zport/dmd/Devices/Layer")
self.assert_(layer not in devices.children())
self.assert_(dc not in devices.getSubOrganizers())
def fetchMetrics(self, dpnames, cf, resolution, start, end="now",
returnSet="ALL"):
"""
Query the server for metrics and return the response.
"""
facade = getFacade('metric', self.dmd)
return facade.queryServer(self, dpnames, cf=cf, start=start, end=end,
downsample=resolution, returnSet=returnSet)
def __init__(self, dmd, twokeydict):
a, b = twokeydict.items()
aid, self.abrains = a
bid, self.bbrains = b
self.a = dmd.unrestrictedTraverse(aid)
self.b = dmd.unrestrictedTraverse(bid)
self.zep = getFacade('zep', dmd)
self.idmgr = Manager(dmd)
def test_updateToMany(self):
from ZenPacks.zenoss.AWS.utils import updateToMany
device_facade = getFacade('device')
instance = self.account.getObjByPath(
'regions/region/instances/instance')
# Add one volume.
updateToMany(instance.volumes,
instance.region().volumes, CLASS_NAME['EC2Volume'],
['volume1'])
self.assertEqual(instance.volumes.countObjects(), 1)
self.assertEqual(instance.volumes()[0].id, 'volume1')
instance_volumes = device_facade.getComponents(
instance.getPrimaryUrlPath(), meta_type='EC2Volume')
self.assertTrue('volume1' in [b.id for b in instance_volumes.results])
# Add two volumes.
updateToMany(instance.volumes,
instance.region().volumes, CLASS_NAME['EC2Volume'],
['volume1', 'volume2'])
self.assertEqual(instance.volumes.countObjects(), 2)
self.assertEqual(set(x.id for x in instance.volumes()),
set(('volume1', 'volume2')))
instance_volumes = device_facade.getComponents(
instance.getPrimaryUrlPath(), meta_type='EC2Volume')
self.assertEqual(instance_volumes.total, 2)
# Remove one volume.
updateToMany(instance.volumes,
instance.region().volumes, CLASS_NAME['EC2Volume'],
['volume2'])
self.assertEqual(instance.volumes.countObjects(), 1)
self.assertEqual(instance.volumes()[0].id, 'volume2')
instance_volumes = device_facade.getComponents(
instance.getPrimaryUrlPath(), meta_type='EC2Volume')
self.assertTrue('volume2' in [b.id for b in instance_volumes.results])
# Remove all volumes.
updateToMany(instance.volumes,
instance.region().volumes, CLASS_NAME['EC2Volume'], [])
self.assertEqual(instance.volumes.countObjects(), 0)
instance_volumes = device_facade.getComponents(
instance.getPrimaryUrlPath(), meta_type='EC2Volume')
self.assertEqual(instance_volumes.total, 0)
def save_return_payload(self, returnPayload):
'''
Process and save the data returned from the callhome server. This
always includes versioning and crypto key changes, and may include
other data to be processed by plugins to the IReturnPayloadProcessor
interface.
'''
try:
returnPayload = zlib.decompress(base64.urlsafe_b64decode(
returnPayload))
returnPayload = json.loads(returnPayload)
except:
logger.debug('Error decoding return payload from server')
return
if all(x in returnPayload for x in ('currentPublicKey',
'revocationList')):
# TODO: VERIFY revocation list, and apply
newPubkey = returnPayload.get('currentPublicKey')
if self.callHome.publicKey != newPubkey:
self.callHome.publicKey = newPubkey
if 'encrypted' in returnPayload:
base64data = base64.urlsafe_b64decode(str(returnPayload.get(
'encrypted')))
data = json.loads(decrypt(base64data, self.callHome.symmetricKey))
if 'compliancereport' in data:
data['compliancereport']['pdf'] = base64.urlsafe_b64decode(str(
data['compliancereport']['pdf']))
if 'latestVersion' in data:
# Save the latest version, and send a
# message if new version available
self.dmd.lastVersionCheck = long(time.time())
available = Version.parse('Zenoss ' + data['latestVersion'])
if (getattr(self.dmd, 'availableVersion', '')
!= available.short()):
self.dmd.availableVersion = available.short()
if self.dmd.About.getZenossVersion() < available:
try:
import socket
zep = getFacade('zep')
summary = ('A new version of Zenoss (%s)' +
'has been released') % available.short()
zep.create(summary, 'Info', socket.getfqdn())
except ZepConnectionError:
logger.warning("ZEP not running - can't send " +
"new version event")
# Go through other data in the return payload, and process
for name, utility in getUtilitiesFor(IReturnPayloadProcessor):
if name in data:
utility.process(self.dmd, data[name])
self.callHome.lastSuccess = long(time.time())
self.chs.updateStat('lastSuccess', long(time.time()))
return
def upgrade(self, configData):
if configData:
self.zep = getFacade('zep')
items = configData.get(EventDetailItemHandler.key, [])
for item in items:
log.info("Upgrading the following to be indexed by ZEP: %s" %
item)
detailItem = from_dict(EventDetailItem, item)
self.zep.updateIndexedDetailItem(detailItem)
def load_device(self,
dmd,
accountname,
accesskey,
secretkey,
collector='localhost'):
return getFacade('aws', dmd).add_ec2account(accountname, accesskey,
secretkey, collector)
def load_device(self, dmd, deviceName, username, api_key, project_id, user_domain_name, project_domain_name, auth_url,
ceilometer_url=None, region_name=None, collector='localhost'):
# we accept, but do not use, the ceilometer_url parameter for backwards
# compatability reasons.
return getFacade('openstackinfrastructure', dmd).addOpenStack(
deviceName, username, api_key, project_id, user_domain_name, project_domain_name, auth_url,
region_name=region_name, collector=collector)
def load_device(self,
dmd,
url,
username,
domain,
password,
collector='localhost'):
return getFacade('oVirt', dmd).add_ovirt(url, username, domain,
password, collector)
def deleteDevices(self, devices=()):
uids = []
for id in devices:
dev = self._dmd.Devices.findDeviceByIdExact(id)
if dev is not None:
uids.append(dev.getPrimaryUrlPath())
if uids:
devFacade = getFacade("device")
devFacade.deleteDevices(uids, deleteEvents=True, deletePerf=True)
def testManageOrganizer(self):
org = self.create(self.dmd,Organizer,'org')
org.dmdRootName = "org"
org.manage_addOrganizer('/foo/bar')
org.manage_addOrganizer('/test/loc')
org.manage_addOrganizer('/number/three')
foo = org.getOrganizer('/foo')
test = org.getOrganizer('/test')
number = org.getOrganizer('/number')
self.assert_(foo in org.children())
self.assert_(test in org.children())
self.assert_(number in org.children())
facade = getFacade('device', self.dmd)
facade.deleteNode('/'.join(foo.getPhysicalPath()))
self.assert_(foo not in org.children())
getFacade('device', self.dmd).deleteNode('/'.join(test.getPhysicalPath()))
getFacade('device', self.dmd).deleteNode('/'.join(number.getPhysicalPath()))
self.assert_(org.children() == [])
def cutover(self, dmd):
zep_facade = getFacade('zep')
triggers_facade = getFacade('triggers')
zp_details = [ det.get('key') for det in zep_facade.getUnmappedDetails() if det.get('key') ]
zp_detail_translator = {}
for zp_detail in zp_details:
zp_detail_translator[zp_detail] = '_'.join(zp_detail.split('.'))
for trigger in triggers_facade.getTriggers():
if trigger.get('rule') and trigger.get('rule').get('source'):
source = trigger.get('rule').get('source')
for zp_detail in zp_details:
if zp_detail in source:
new_source = self._migrate_detail_in_trigger(source, zp_detail, zp_detail_translator)
trigger['rule']['source'] = new_source
triggers_facade.updateTrigger(**trigger)
print "Trigger {0} updated.".format(trigger.get('name'))
def cutover(self, dmd):
zep_facade = getFacade("zep")
triggers_facade = getFacade("triggers")
zp_details = [det.get("key") for det in zep_facade.getUnmappedDetails() if det.get("key")]
zp_detail_translator = {}
for zp_detail in zp_details:
zp_detail_translator[zp_detail] = "_".join(zp_detail.split("."))
for trigger in triggers_facade.getTriggers():
if trigger.get("rule") and trigger.get("rule").get("source"):
source = trigger.get("rule").get("source")
for zp_detail in zp_details:
if zp_detail in source:
new_source = self._migrate_detail_in_trigger(source, zp_detail, zp_detail_translator)
trigger["rule"]["source"] = new_source
triggers_facade.updateTrigger(**trigger)
print "Trigger {0} updated.".format(trigger.get("name"))
def add_aliases(dmd, datapoint, aliases):
tf = getFacade("template", dmd)
data = []
for id_ in aliases.keys():
id_ = str(id_)
if aliases[id_]["formula"] is None:
aliases[id_]["formula"] = ""
data.append({"id": id_, "formula": aliases[id_]["formula"]})
tf.setInfo(datapoint.uid, {"aliases": data})
def add_aliases(dmd, datapoint, aliases):
tf = getFacade('template', dmd)
data = []
for id_ in aliases.keys():
id_ = str(id_)
if aliases[id_]['formula'] is None:
aliases[id_]['formula'] = ""
data.append({'id': id_, 'formula': aliases[id_]['formula']})
tf.setInfo(datapoint.uid, {'aliases': data})
