def zmanage_editProperties(self, REQUEST=None):
'''validation, etc'''
if REQUEST:
# ensure default datapoint didn't go away
self.addDataPoints()
# and eventClass
if not REQUEST.form.get('eventClass', None):
REQUEST.form['eventClass'] = self.__class__.eventClass
return BasicDataSource.zmanage_editProperties(self, REQUEST)
def zmanage_editProperties(self, REQUEST=None):
"""Validate input before updating properties."""
if REQUEST:
if not REQUEST.form.get('splunkSearch'):
messaging.IMessageSender(self).sendToBrowser(
'Update Failed',
'Search cannot be blank.',
priority=messaging.WARNING)
return self.callZenScreen(REQUEST)
return BasicDataSource.zmanage_editProperties(self, REQUEST)
def zmanage_editProperties(self, REQUEST=None):
"""Validate input before updating properties."""
if REQUEST:
if not REQUEST.form.get('splunkSearch'):
messaging.IMessageSender(self).sendToBrowser(
'Update Failed',
'Search cannot be blank.',
priority=messaging.WARNING)
return self.callZenScreen(REQUEST)
return BasicDataSource.zmanage_editProperties(self, REQUEST)
def getCommand(self, context):
parts = ['check_db_replication.py']
parts.append('-H %s' % context.manageIp)
if self.username:
parts.append("-u '%s'" % self.username)
if self.password:
parts.append("-w '%s'" % self.password)
cmd = ' '.join(parts)
cmd = BasicDataSource.getCommand(self, context, cmd)
return cmd
def getCommand(self, context):
parts = ['check_splunk.py']
if self.splunkServer:
parts.append("-s %s" % self.splunkServer)
if self.splunkPort:
parts.append("-p %s" % self.splunkPort)
if self.splunkUsername:
parts.append("-u '%s'" % self.splunkUsername)
if self.splunkPassword:
parts.append("-w '%s'" % self.splunkPassword)
if self.splunkSearch:
parts.append("'%s'" % self.splunkSearch)
return BasicDataSource.getCommand(self, context, ' '.join(parts))
def getCommand(self, context):
parts = ['check_splunk.py']
if self.splunkServer:
parts.append("-s %s" % self.splunkServer)
if self.splunkPort:
parts.append("-p %s" % self.splunkPort)
if self.splunkUsername:
parts.append("-u '%s'" % self.splunkUsername)
if self.splunkPassword:
parts.append("-w '%s'" % self.splunkPassword)
if self.splunkSearch:
parts.append("'%s'" % self.splunkSearch)
return BasicDataSource.getCommand(self, context, ' '.join(parts))
def cutover(self, dmd):
if hasattr(dmd.Devices.rrdTemplates, 'ethernetCsmacd_64'):
template = dmd.Devices.rrdTemplates._getOb('ethernetCsmacd_64')
if not hasattr(template.datasources, "ifOperStatus"):
bds = BasicDataSource('ifOperStatus')
bds.oid = ".1.3.6.1.2.1.2.2.1.8"
bds.sourcetype = "SNMP"
template.datasources._setObject('ifOperStatus', bds)
bds = template.datasources.ifOperStatus
bds.addDataPoints()
datapoint = template.datasources.ifOperStatus.datapoints.ifOperStatus
datapoint.createCmd = "\n".join((
'RRA:LAST:0.5:1:600',
'RRA:AVERAGE:0.5:1:600', # every 5 mins for 2 days
'RRA:AVERAGE:0.5:6:600', # every 30 mins for 12 days
'RRA:AVERAGE:0.5:24:600', # every 2 hours for 50 days
'RRA:AVERAGE:0.5:288:600', # every day for 600 days
'RRA:MAX:0.5:6:600',
'RRA:MAX:0.5:24:600',
'RRA:MAX:0.5:288:600',
))
def __init__(self, id, title=None, buildRelations=True):
BasicDataSource.__init__(self, id, title, buildRelations)
def getCommand(self, context):
""" use check_kannel to retrieve status info """
return BasicDataSource.getCommand(self, context, self._cmd())
def getDescription(self):
""" DEBUGSTR """
if self.sourcetype == self.KANNEL_MONITOR:
return self._cmd()
return BasicDataSource.getDescription(self)
def test_getCycleTime(self):
deviceclass = self.dmd.Devices.createOrganizer(
"/Test/CalculatedPerformance")
deviceclass.setZenProperty("zCollectorClientTimeout", 20)
# Basis datasources.
deviceclass.manage_addRRDTemplate("FileSystem")
basis_template = deviceclass.rrdTemplates._getOb("FileSystem")
command_ds = BasicDataSource("command")
basis_template.datasources._setObject(command_ds.id, command_ds)
command_ds = basis_template.datasources._getOb(command_ds.id)
command_ds.sourcetype = "COMMAND"
command_ds.cycletime = 10
command_ds.manage_addRRDDataPoint("command")
python_ds = PythonDataSource("python")
basis_template.datasources._setObject(python_ds.id, python_ds)
python_ds = basis_template.datasources._getOb(python_ds.id)
python_ds.cycletime = "${here/zCollectorClientTimeout}"
python_ds.manage_addRRDDataPoint("python")
# Aggregating datasources.
deviceclass.manage_addRRDTemplate("Device")
agg_template = deviceclass.rrdTemplates._getOb("Device")
agg_ds1 = AggregatingDataSource("agg1")
agg_template.datasources._setObject(agg_ds1.id, agg_ds1)
agg_ds1 = agg_template.datasources._getOb(agg_ds1.id)
agg_ds1.targetMethod = "os.filesystems"
agg_ds1.targetDataSource = "command"
agg_ds1.targetDataPoint = "command"
agg_ds1.useBasisInterval = False
agg_ds1.cycletime = 30
agg_ds2 = AggregatingDataSource("agg2")
agg_template.datasources._setObject(agg_ds2.id, agg_ds2)
agg_ds2 = agg_template.datasources._getOb(agg_ds2.id)
agg_ds2.targetMethod = "os.filesystems"
agg_ds2.targetDataSource = "python"
agg_ds2.targetDataPoint = "python"
agg_ds2.useBasisInterval = True
agg_ds2.cycletime = 40
# Device
device = deviceclass.createInstance("TestCalculatedPerformance")
device.setPerformanceMonitor("localhost")
# Members
fs1 = FileSystem("boot")
device.os.filesystems._setObject(fs1.id, fs1)
fs2 = FileSystem("root")
device.os.filesystems._setObject(fs2.id, fs2)
# Sanity checks.
self.assertEqual(command_ds.cycletime, 10)
self.assertEqual(python_ds.getCycleTime(device), 20)
# useBasisInterval = False
self.assertEqual(agg_ds1.getCycleTime(device), 30)
# useBasisInterval = True
self.assertEqual(agg_ds2.getCycleTime(device), 20)
# minimumInterval
agg_ds2.minimumInterval = None
self.assertEqual(agg_ds2.getCycleTime(device), 20)
agg_ds2.minimumInterval = 1
self.assertEqual(agg_ds2.getCycleTime(device), 20)
agg_ds2.minimumInterval = 40
self.assertEqual(agg_ds2.getCycleTime(device), 40)
agg_ds2.minimumInterval = None
# maximumInterval
agg_ds2.maximumInterval = None
self.assertEqual(agg_ds2.getCycleTime(device), 20)
agg_ds2.maximumInterval = 40
self.assertEqual(agg_ds2.getCycleTime(device), 20)
agg_ds2.maximumInterval = 1
self.assertEqual(agg_ds2.getCycleTime(device), 1)
agg_ds2.maximumInterval = None
def test_getCycleTime(self):
deviceclass = self.dmd.Devices.createOrganizer(
"/Test/CalculatedPerformance")
deviceclass.setZenProperty("zCollectorClientTimeout", 20)
deviceclass.manage_addRRDTemplate("Device")
template = deviceclass.rrdTemplates._getOb("Device")
# Basis datasources.
basis_ds1 = BasicDataSource("basis1")
template.datasources._setObject(
basis_ds1.id, basis_ds1)
basis_ds1 = template.datasources._getOb(basis_ds1.id)
basis_ds1.sourcetype = "COMMAND"
basis_ds1.cycletime = 10
basis_ds1.manage_addRRDDataPoint("basis1")
basis_ds2 = PythonDataSource("basis2")
template.datasources._setObject(basis_ds2.id, basis_ds2)
basis_ds2 = template.datasources._getOb(basis_ds2.id)
basis_ds2.cycletime = "${here/zCollectorClientTimeout}"
basis_ds2.manage_addRRDDataPoint("basis2")
# Calculated datasources.
calc_ds1 = CalculatedPerformanceDataSource("calculated1")
template.datasources._setObject(calc_ds1.id, calc_ds1)
calc_ds1 = template.datasources._getOb(calc_ds1.id)
calc_ds1.expression = "basis1 + basis2"
calc_ds1.useBasisInterval = False
calc_ds1.cycletime = 30
calc_ds1.manage_addRRDDataPoint("calculated1")
calc_ds2 = CalculatedPerformanceDataSource("calculated2")
template.datasources._setObject(calc_ds2.id, calc_ds2)
calc_ds2 = template.datasources._getOb(calc_ds2.id)
calc_ds2.expression = "basis1 + basis2"
calc_ds2.useBasisInterval = True
calc_ds2.cycletime = 40
calc_ds2.manage_addRRDDataPoint("calculated2")
# Device
device = deviceclass.createInstance("TestCalculatedPerformance")
device.setPerformanceMonitor("localhost")
# Santity checks.
self.assertEqual(basis_ds1.cycletime, 10)
self.assertEqual(basis_ds2.getCycleTime(device), 20)
# useBasisInterval = False
self.assertEqual(calc_ds1.getCycleTime(device), 30)
# useBasisInterval = True
self.assertEqual(calc_ds2.getCycleTime(device), 10)
# minimumInterval
calc_ds2.minimumInterval = None
self.assertEqual(calc_ds2.getCycleTime(device), 10)
calc_ds2.minimumInterval = 1
self.assertEqual(calc_ds2.getCycleTime(device), 10)
calc_ds2.minimumInterval = 20
self.assertEqual(calc_ds2.getCycleTime(device), 20)
calc_ds2.minimumInterval = None
# maximumInterval
calc_ds2.maximumInterval = None
self.assertEqual(calc_ds2.getCycleTime(device), 10)
calc_ds2.maximumInterval = 20
self.assertEqual(calc_ds2.getCycleTime(device), 10)
calc_ds2.maximumInterval = 1
self.assertEqual(calc_ds2.getCycleTime(device), 1)
calc_ds2.maximumInterval = None
