def doTask(self):
log.debug("Scanning device %s [%s]", self._devId, self._manageIp)
self._eventsFetched = 0
# see if we need to connect first before doing any collection
if not self._watcher:
d = self._connect()
d.addCallbacks(self._connectCallback, self._failure)
else:
# since we don't need to bother connecting, we'll just create an
# empty deferred and have it run immediately so the collect callback
# will be fired off
d = defer.Deferred()
reactor.callLater(0, d.callback, None)
# try collecting events after a successful connect, or if we're already
# connected
d.addCallback(self._collectCallback)
# Add the _finished callback to be called in both success and error
# scenarios. While we don't need final error processing in this task,
# it is good practice to catch any final errors for diagnostic purposes.
d.addBoth(self._finished)
# returning a Deferred will keep the framework from assuming the task
# is done until the Deferred actually completes
return d
def _collectSuccessful(self, result):
"""
Callback for a successful fetch of events from the remote device.
"""
self.state = ZenEventLogTask.STATE_PROCESSING
log.debug("Successful collection from %s [%s], result=%s",
self._devId, self._manageIp, result)
events = result
if events:
# process all of the fetched events
for logRecord in events:
self._eventsFetched += 1
# TODO: figure out how to post this state on the cycle interval
self._eventService.sendEvent(self._makeEvent(logRecord))
# schedule another immediate collection so that we'll keep eating
# events as long as they are ready for us; using callLater ensures
# it goes to the end of the immediate work-queue so that other
# events get processing time
log.debug("Queuing another fetch for %s [%s]",
self._devId, self._manageIp)
d = defer.Deferred()
reactor.callLater(0, d.callback, None)
d.addCallback(self._collectCallback)
return d
def connected(self):
"""
Called after connected to the zenhub service
"""
reactor.callLater(_CONFIG_PULLING_TIMEOUT, self._checkConfigLoad)
d = self.configure()
d.addCallback(self.heartbeat)
d.addErrback(self.reportError)
def _checkConfigLoad(self):
"""
Looping call to check whether zenmodeler got configuration
from ZenHub.
"""
if not self.configLoaded:
self.log.info(
"Modeling has not started pending configuration "
"pull from ZenHub. Is ZenHub overloaded?"
)
reactor.callLater(_CONFIG_PULLING_TIMEOUT, self._checkConfigLoad)
def timeoutClients(self, unused=None):
"""
Check to see which clients have timed out and which ones haven't.
Stop processing anything that's timed out.
@param unused: unused (unused)
@type unused: string
"""
reactor.callLater(1, self.timeoutClients)
self._timeoutClients()
d = drive(self.fillCollectionSlots)
d.addCallback(self.checkStop)
d.addErrback(self.fillError)
def heartbeat(self, ignored=None):
"""
Twisted keep-alive mechanism to ensure that
we're still connected to zenhub
@param ignored: object (unused)
@type ignored: object
"""
ARBITRARY_BEAT = 30
reactor.callLater(ARBITRARY_BEAT, self.heartbeat)
if self.options.cycle:
evt = dict(eventClass=Heartbeat,
component='zenmodeler',
device=self.options.monitor,
timeout=self.options.heartbeatTimeout)
self.sendEvent(evt)
self.niceDoggie(self.cycleTime())
# We start modeling from here to accomodate the startup delay.
if not self.started:
if self.immediate == 0 and self.startat:
# This stuff relies on ARBITRARY_BEAT being < 60s
if self.timeMatches():
self.started = True
self.log.info("Starting modeling...")
reactor.callLater(1, self.main)
else:
self.started = True
self.log.info("Starting modeling in %s seconds.",
self.startDelay)
reactor.callLater(self.startDelay, self.main)
def heartbeat(self, ignored=None):
"""
Twisted keep-alive mechanism to ensure that
we're still connected to zenhub
@param ignored: object (unused)
@type ignored: object
"""
ARBITRARY_BEAT = 30
reactor.callLater(ARBITRARY_BEAT, self.heartbeat)
if self.options.cycle:
evt = dict(eventClass=Heartbeat,
component='zenmodeler',
device=self.options.monitor,
timeout=self.options.heartbeatTimeout)
self.sendEvent(evt)
self.niceDoggie(self.cycleTime())
# We start modeling from here to accomodate the startup delay.
if not self.started:
if self.immediate == 0 and self.startat:
# This stuff relies on ARBITRARY_BEAT being < 60s
if self.timeMatches():
self.started = True
self.log.info("Starting modeling...")
reactor.callLater(1, self.main)
else:
self.started = True
self.log.info("Starting modeling in %s seconds.", self.startDelay)
reactor.callLater(self.startDelay, self.main)
def inner(driver):
"""
Generator function to gather our configuration
@param driver: driver object
@type driver: driver object
"""
self.log.debug('fetching monitor properties')
yield self.config().callRemote('propertyItems')
items = dict(driver.next())
# If the cycletime option is not specified or zero, then use the
# modelerCycleInterval value in the database.
if not self.options.cycletime:
self.modelerCycleInterval = items.get('modelerCycleInterval',
_DEFAULT_CYCLE_INTERVAL)
self.configCycleInterval = items.get('configCycleInterval',
self.configCycleInterval)
reactor.callLater(self.configCycleInterval * 60, self.configure)
self.log.debug("Getting threshold classes...")
yield self.config().callRemote('getThresholdClasses')
self.remote_updateThresholdClasses(driver.next())
self.log.debug("Getting collector thresholds...")
yield self.config().callRemote('getCollectorThresholds')
thresholds = driver.next()
threshold_notifier = ThresholdNotifier(self.sendEvent, thresholds)
self.rrdStats.config(self.name,
self.options.monitor,
self.metricWriter(),
threshold_notifier,
self.derivativeTracker())
self.log.debug("Getting collector plugins for each DeviceClass")
yield self.config().callRemote('getClassCollectorPlugins')
self.classCollectorPlugins = driver.next()
self.configLoaded = True
def inner(driver):
"""
Generator function to gather our configuration
@param driver: driver object
@type driver: driver object
"""
self.log.debug('fetching monitor properties')
yield self.config().callRemote('propertyItems')
items = dict(driver.next())
# If the cycletime option is not specified or zero, then use the
# modelerCycleInterval value in the database.
if not self.options.cycletime:
self.modelerCycleInterval = items.get('modelerCycleInterval',
_DEFAULT_CYCLE_INTERVAL)
self.configCycleInterval = items.get('configCycleInterval',
self.configCycleInterval)
reactor.callLater(self.configCycleInterval * 60, self.configure)
self.log.debug("Getting threshold classes...")
yield self.config().callRemote('getThresholdClasses')
self.remote_updateThresholdClasses(driver.next())
self.log.debug("Getting collector thresholds...")
yield self.config().callRemote('getCollectorThresholds')
thresholds = driver.next()
threshold_notifier = ThresholdNotifier(self.sendEvent, thresholds)
self.rrdStats.config(self.name, self.options.monitor,
self.metricWriter(), threshold_notifier,
self.derivativeTracker())
self.log.debug("Getting collector plugins for each DeviceClass")
yield self.config().callRemote('getClassCollectorPlugins')
self.classCollectorPlugins = driver.next()
self.configLoaded = True
def heartbeat(self, ignored=None):
"""
Twisted keep-alive mechanism to ensure that
we're still connected to zenhub
@param ignored: object (unused)
@type ignored: object
"""
ARBITRARY_BEAT = 30
reactor.callLater(ARBITRARY_BEAT, self.heartbeat)
if self.options.cycle:
evt = dict(eventClass=Heartbeat,
component='zenmodeler',
device=self.options.monitor,
timeout=3 * ARBITRARY_BEAT)
self.sendEvent(evt)
self.niceDoggie(self.cycleTime())
# We start modeling from here to accomodate the startup delay.
if not self.started:
if self.immediate == 0 and self.startat:
# This stuff relies on ARBITRARY_BEAT being < 60s
if self.timeMatches():
self.started = True
reactor.callLater(1, self.main)
else:
self.started = True
reactor.callLater(self.startDelay, self.main)
# save modeled device rate
self.rrdStats.derive('modeledDevices', ARBITRARY_BEAT,
self.counters['modeledDevicesCount'])
# save running count
self.rrdStats.gauge('modeledDevicesCount', ARBITRARY_BEAT,
self.counters['modeledDevicesCount'])
# persist counters values
self.saveCounters()
def heartbeat(self, ignored=None):
"""
Twisted keep-alive mechanism to ensure that
we're still connected to zenhub
@param ignored: object (unused)
@type ignored: object
"""
ARBITRARY_BEAT = 30
reactor.callLater(ARBITRARY_BEAT, self.heartbeat)
if self.options.cycle:
evt = dict(eventClass=Heartbeat,
component='zenmodeler',
device=self.options.monitor,
timeout=3*ARBITRARY_BEAT)
self.sendEvent(evt)
self.niceDoggie(self.cycleTime())
# We start modeling from here to accomodate the startup delay.
if not self.started:
if self.immediate == 0 and self.startat:
# This stuff relies on ARBITRARY_BEAT being < 60s
if self.timeMatches():
self.started = True
reactor.callLater(1, self.main)
else:
self.started = True
reactor.callLater(self.startDelay, self.main)
# save modeled device rate
self.rrdStats.derive('modeledDevices', self.counters['modeledDevicesCount'])
# save running count
self.rrdStats.gauge('modeledDevicesCount', self.counters['modeledDevicesCount'])
# persist counters values
self.saveCounters()