def getConfigProxies(self, prefs, ids=[]):
if not ICollectorPreferences.providedBy(prefs):
raise TypeError("config must provide ICollectorPreferences")
self._collector = zope.component.queryUtility(ICollector)
serviceProxy = self._collector.getRemoteConfigServiceProxy()
log.debug("Fetching configurations")
d = serviceProxy.callRemote('getDeviceConfigs', ids)
return d
def getConfigProxies(self, prefs, ids=[]):
if not ICollectorPreferences.providedBy(prefs):
raise TypeError("config must provide ICollectorPreferences")
self._collector = zope.component.queryUtility(ICollector)
serviceProxy = self._collector.getRemoteConfigServiceProxy()
log.debug("Fetching configurations")
d = serviceProxy.callRemote('getDeviceConfigs', ids)
return d
def getThresholds(self, prefs):
if not ICollectorPreferences.providedBy(prefs):
raise TypeError("config must provide ICollectorPreferences")
self._collector = zope.component.queryUtility(ICollector)
serviceProxy = self._collector.getRemoteConfigServiceProxy()
log.debug("Fetching collector thresholds")
d = serviceProxy.callRemote('getCollectorThresholds')
return d
def getThresholds(self, prefs):
if not ICollectorPreferences.providedBy(prefs):
raise TypeError("config must provide ICollectorPreferences")
self._collector = zope.component.queryUtility(ICollector)
serviceProxy = self._collector.getRemoteConfigServiceProxy()
log.debug("Fetching collector thresholds")
d = serviceProxy.callRemote('getCollectorThresholds')
return d
def getPropertyItems(self, prefs):
if not ICollectorPreferences.providedBy(prefs):
raise TypeError("config must provide ICollectorPreferences")
self._collector = zope.component.queryUtility(ICollector)
serviceProxy = self._collector.getRemoteConfigServiceProxy()
# Load any configuration properties for this daemon
log.debug("Fetching daemon configuration properties")
d = serviceProxy.callRemote('getConfigProperties')
d.addCallback(lambda result: dict(result))
return d
def getPropertyItems(self, prefs):
if not ICollectorPreferences.providedBy(prefs):
raise TypeError("config must provide ICollectorPreferences")
self._collector = zope.component.queryUtility(ICollector)
serviceProxy = self._collector.getRemoteConfigServiceProxy()
# Load any configuration properties for this daemon
log.debug("Fetching daemon configuration properties")
d = serviceProxy.callRemote('getConfigProperties')
d.addCallback(lambda result: dict(result))
return d
def getConfigNames(self, result, prefs):
if not ICollectorPreferences.providedBy(prefs):
raise TypeError("config must provide ICollectorPreferences")
self._collector = zope.component.queryUtility(ICollector)
serviceProxy = self._collector.getRemoteConfigServiceProxy()
log.debug("Fetching device names")
d = serviceProxy.callRemote('getDeviceNames', options=prefs.options.__dict__)
def printNames (names):
log.debug("workerid %s Fetched Names %s %s", prefs.options.workerid, len(names), names)
return names
d.addCallback(printNames)
return d
def getConfigNames(self, result, prefs):
if not ICollectorPreferences.providedBy(prefs):
raise TypeError("config must provide ICollectorPreferences")
self._collector = zope.component.queryUtility(ICollector)
serviceProxy = self._collector.getRemoteConfigServiceProxy()
log.debug("Fetching device names")
d = serviceProxy.callRemote('getDeviceNames',
options=prefs.options.__dict__)
def printNames(names):
log.debug("workerid %s Fetched Names %s %s",
prefs.options.workerid, len(names), names)
return names
d.addCallback(printNames)
return d
def __init__(self, preferences, taskSplitter,
configurationListener=DUMMY_LISTENER,
initializationCallback=None,
stoppingCallback=None):
"""
Constructs a new instance of the CollectorDaemon framework. Normally
only a singleton instance of a CollectorDaemon should exist within a
process, but this is not enforced.
@param preferences: the collector configuration
@type preferences: ICollectorPreferences
@param taskSplitter: the task splitter to use for this collector
@type taskSplitter: ITaskSplitter
@param initializationCallback: a callable that will be executed after
connection to the hub but before
retrieving configuration information
@type initializationCallback: any callable
@param stoppingCallback: a callable that will be executed first during
the stopping process. Exceptions will be
logged but otherwise ignored.
@type stoppingCallback: any callable
"""
# create the configuration first, so we have the collector name
# available before activating the rest of the Daemon class hierarchy.
if not ICollectorPreferences.providedBy(preferences):
raise TypeError("configuration must provide ICollectorPreferences")
else:
self._prefs = ObservableProxy(preferences)
self._prefs.attachAttributeObserver('configCycleInterval', self._rescheduleConfig)
if not ITaskSplitter.providedBy(taskSplitter):
raise TypeError("taskSplitter must provide ITaskSplitter")
else:
self._taskSplitter = taskSplitter
if not IConfigurationListener.providedBy(configurationListener):
raise TypeError(
"configurationListener must provide IConfigurationListener")
self._configListener = ConfigListenerNotifier()
self._configListener.addListener(configurationListener)
self._configListener.addListener(DeviceGuidListener(self))
self._initializationCallback = initializationCallback
self._stoppingCallback = stoppingCallback
# register the various interfaces we provide the rest of the system so
# that collector implementors can easily retrieve a reference back here
# if needed
zope.component.provideUtility(self, ICollector)
zope.component.provideUtility(self, IEventService)
zope.component.provideUtility(self, IDataService)
# setup daemon statistics
self._statService = StatisticsService()
self._statService.addStatistic("devices", "GAUGE")
self._statService.addStatistic("dataPoints", "DERIVE")
self._statService.addStatistic("runningTasks", "GAUGE")
self._statService.addStatistic("taskCount", "GAUGE")
self._statService.addStatistic("queuedTasks", "GAUGE")
self._statService.addStatistic("missedRuns", "GAUGE")
zope.component.provideUtility(self._statService, IStatisticsService)
# register the collector's own preferences object so it may be easily
# retrieved by factories, tasks, etc.
zope.component.provideUtility(self.preferences,
ICollectorPreferences,
self.preferences.collectorName)
super(CollectorDaemon, self).__init__(name=self.preferences.collectorName)
self._deviceGuids = {}
self._devices = set()
self._unresponsiveDevices = set()
self._rrd = None
self._metric_writer = None
self._derivative_tracker = None
self.reconfigureTimeout = None
# keep track of pending tasks if we're doing a single run, and not a
# continuous cycle
if not self.options.cycle:
self._completedTasks = 0
self._pendingTasks = []
frameworkFactory = zope.component.queryUtility(IFrameworkFactory, self._frameworkFactoryName)
self._configProxy = frameworkFactory.getConfigurationProxy()
self._scheduler = frameworkFactory.getScheduler()
self._scheduler.maxTasks = self.options.maxTasks
self._ConfigurationLoaderTask = frameworkFactory.getConfigurationLoaderTask()
# OLD - set the initialServices attribute so that the PBDaemon class
# will load all of the remote services we need.
self.initialServices = PBDaemon.initialServices +\
[self.preferences.configurationService]
# trap SIGUSR2 so that we can display detailed statistics
signal.signal(signal.SIGUSR2, self._signalHandler)
# let the configuration do any additional startup it might need
self.preferences.postStartup()
self.addedPostStartupTasks = False
def __init__(self,
preferences,
taskSplitter,
configurationListener=DUMMY_LISTENER,
initializationCallback=None,
stoppingCallback=None):
"""
Constructs a new instance of the CollectorDaemon framework. Normally
only a singleton instance of a CollectorDaemon should exist within a
process, but this is not enforced.
@param preferences: the collector configuration
@type preferences: ICollectorPreferences
@param taskSplitter: the task splitter to use for this collector
@type taskSplitter: ITaskSplitter
@param initializationCallback: a callable that will be executed after
connection to the hub but before
retrieving configuration information
@type initializationCallback: any callable
@param stoppingCallback: a callable that will be executed first during
the stopping process. Exceptions will be
logged but otherwise ignored.
@type stoppingCallback: any callable
"""
# create the configuration first, so we have the collector name
# available before activating the rest of the Daemon class hierarchy.
if not ICollectorPreferences.providedBy(preferences):
raise TypeError("configuration must provide ICollectorPreferences")
else:
self._prefs = ObservableProxy(preferences)
self._prefs.attachAttributeObserver('configCycleInterval',
self._rescheduleConfig)
if not ITaskSplitter.providedBy(taskSplitter):
raise TypeError("taskSplitter must provide ITaskSplitter")
else:
self._taskSplitter = taskSplitter
if not IConfigurationListener.providedBy(configurationListener):
raise TypeError(
"configurationListener must provide IConfigurationListener")
self._configListener = ConfigListenerNotifier()
self._configListener.addListener(configurationListener)
self._configListener.addListener(DeviceGuidListener(self))
self._initializationCallback = initializationCallback
self._stoppingCallback = stoppingCallback
# register the various interfaces we provide the rest of the system so
# that collector implementors can easily retrieve a reference back here
# if needed
zope.component.provideUtility(self, ICollector)
zope.component.provideUtility(self, IEventService)
zope.component.provideUtility(self, IDataService)
# register the collector's own preferences object so it may be easily
# retrieved by factories, tasks, etc.
zope.component.provideUtility(self.preferences, ICollectorPreferences,
self.preferences.collectorName)
super(CollectorDaemon,
self).__init__(name=self.preferences.collectorName)
self._statService = StatisticsService()
zope.component.provideUtility(self._statService, IStatisticsService)
if self.options.cycle:
# setup daemon statistics (deprecated names)
self._statService.addStatistic("devices", "GAUGE")
self._statService.addStatistic("dataPoints", "DERIVE")
self._statService.addStatistic("runningTasks", "GAUGE")
self._statService.addStatistic("taskCount", "GAUGE")
self._statService.addStatistic("queuedTasks", "GAUGE")
self._statService.addStatistic("missedRuns", "GAUGE")
# namespace these a bit so they can be used in ZP monitoring.
# prefer these stat names and metrology in future refs
self._dataPointsMetric = Metrology.meter(
"collectordaemon.dataPoints")
daemon = self
class DeviceGauge(Gauge):
@property
def value(self):
return len(daemon._devices)
Metrology.gauge('collectordaemon.devices', DeviceGauge())
# Scheduler statistics
class RunningTasks(Gauge):
@property
def value(self):
return daemon._scheduler._executor.running
Metrology.gauge('collectordaemon.runningTasks', RunningTasks())
class TaskCount(Gauge):
@property
def value(self):
return daemon._scheduler.taskCount
Metrology.gauge('collectordaemon.taskCount', TaskCount())
class QueuedTasks(Gauge):
@property
def value(self):
return daemon._scheduler._executor.queued
Metrology.gauge('collectordaemon.queuedTasks', QueuedTasks())
class MissedRuns(Gauge):
@property
def value(self):
return daemon._scheduler.missedRuns
Metrology.gauge('collectordaemon.missedRuns', MissedRuns())
self._deviceGuids = {}
self._devices = set()
self._unresponsiveDevices = set()
self._rrd = None
self._metric_writer = None
self._derivative_tracker = None
self.reconfigureTimeout = None
# keep track of pending tasks if we're doing a single run, and not a
# continuous cycle
if not self.options.cycle:
self._completedTasks = 0
self._pendingTasks = []
frameworkFactory = zope.component.queryUtility(
IFrameworkFactory, self._frameworkFactoryName)
self._configProxy = frameworkFactory.getConfigurationProxy()
self._scheduler = frameworkFactory.getScheduler()
self._scheduler.maxTasks = self.options.maxTasks
self._ConfigurationLoaderTask = frameworkFactory.getConfigurationLoaderTask(
)
# OLD - set the initialServices attribute so that the PBDaemon class
# will load all of the remote services we need.
self.initialServices = PBDaemon.initialServices +\
[self.preferences.configurationService]
# trap SIGUSR2 so that we can display detailed statistics
signal.signal(signal.SIGUSR2, self._signalHandler)
# let the configuration do any additional startup it might need
self.preferences.postStartup()
self.addedPostStartupTasks = False
# Variables used by enterprise collector in resmgr
#
# flag that indicates we have finished loading the configs for the first time after a restart
self.firstConfigLoadDone = False
# flag that indicates the daemon has received the encryption key from zenhub
self.encryptionKeyInitialized = False
# flag that indicates the daemon is loading the cached configs
self.loadingCachedConfigs = False
def updateConfigProxy(self, prefs, config):
if not ICollectorPreferences.providedBy(prefs):
raise TypeError("config must provide ICollectorPreferences")
# not implemented in the basic ConfigurationProxy
return defer.succeed(None)
def __init__(self,
preferences,
taskSplitter,
configurationListener=DUMMY_LISTENER,
initializationCallback=None,
stoppingCallback=None):
"""
Constructs a new instance of the CollectorDaemon framework. Normally
only a singleton instance of a CollectorDaemon should exist within a
process, but this is not enforced.
@param preferences: the collector configuration
@type preferences: ICollectorPreferences
@param taskSplitter: the task splitter to use for this collector
@type taskSplitter: ITaskSplitter
@param initializationCallback: a callable that will be executed after
connection to the hub but before
retrieving configuration information
@type initializationCallback: any callable
@param stoppingCallback: a callable that will be executed first during
the stopping process. Exceptions will be
logged but otherwise ignored.
@type stoppingCallback: any callable
"""
# create the configuration first, so we have the collector name
# available before activating the rest of the Daemon class hierarchy.
if not ICollectorPreferences.providedBy(preferences):
raise TypeError("configuration must provide ICollectorPreferences")
else:
self._prefs = ObservableProxy(preferences)
self._prefs.attachAttributeObserver('configCycleInterval',
self._rescheduleConfig)
if not ITaskSplitter.providedBy(taskSplitter):
raise TypeError("taskSplitter must provide ITaskSplitter")
else:
self._taskSplitter = taskSplitter
if not IConfigurationListener.providedBy(configurationListener):
raise TypeError(
"configurationListener must provide IConfigurationListener")
self._configListener = ConfigListenerNotifier()
self._configListener.addListener(configurationListener)
self._configListener.addListener(DeviceGuidListener(self))
self._initializationCallback = initializationCallback
self._stoppingCallback = stoppingCallback
# register the various interfaces we provide the rest of the system so
# that collector implementors can easily retrieve a reference back here
# if needed
zope.component.provideUtility(self, ICollector)
zope.component.provideUtility(self, IEventService)
zope.component.provideUtility(self, IDataService)
# setup daemon statistics
self._statService = StatisticsService()
self._statService.addStatistic("devices", "GAUGE")
self._statService.addStatistic("cyclePoints", "GAUGE")
self._statService.addStatistic("dataPoints", "DERIVE")
self._statService.addStatistic("runningTasks", "GAUGE")
self._statService.addStatistic("queuedTasks", "GAUGE")
self._statService.addStatistic("missedRuns", "GAUGE")
zope.component.provideUtility(self._statService, IStatisticsService)
# register the collector's own preferences object so it may be easily
# retrieved by factories, tasks, etc.
zope.component.provideUtility(self.preferences, ICollectorPreferences,
self.preferences.collectorName)
super(CollectorDaemon,
self).__init__(name=self.preferences.collectorName)
self._deviceGuids = {}
self._devices = set()
self._thresholds = Thresholds()
self._unresponsiveDevices = set()
self._rrd = None
self.reconfigureTimeout = None
# keep track of pending tasks if we're doing a single run, and not a
# continuous cycle
if not self.options.cycle:
self._completedTasks = 0
self._pendingTasks = []
frameworkFactory = zope.component.queryUtility(
IFrameworkFactory, self._frameworkFactoryName)
self._configProxy = frameworkFactory.getConfigurationProxy()
self._scheduler = frameworkFactory.getScheduler()
self._scheduler.maxTasks = self.options.maxTasks
self._ConfigurationLoaderTask = frameworkFactory.getConfigurationLoaderTask(
)
# OLD - set the initialServices attribute so that the PBDaemon class
# will load all of the remote services we need.
self.initialServices = PBDaemon.initialServices +\
[self.preferences.configurationService]
# trap SIGUSR2 so that we can display detailed statistics
signal.signal(signal.SIGUSR2, self._signalHandler)
# let the configuration do any additional startup it might need
self.preferences.postStartup()
self.addedPostStartupTasks = False
def updateConfigProxy(self, prefs, config):
if not ICollectorPreferences.providedBy(prefs):
raise TypeError("config must provide ICollectorPreferences")
# not implemented in the basic ConfigurationProxy
return defer.succeed(None)
