def __init__(self): ZCmdBase.__init__(self) self.current = IDLE self.currentStart = 0 self.numCalls = 0 try: self.log.debug("establishing SIGUSR2 signal handler") signal.signal(signal.SIGUSR2, self.sighandler_USR2) except ValueError: # If we get called multiple times, this will generate an exception: # ValueError: signal only works in main thread # Ignore it as we've already set up the signal handler. pass self.zem = self.dmd.ZenEventManager loadPlugins(self.dmd) self.pid = os.getpid() self.services = {} factory = ReconnectingPBClientFactory() self.log.debug("Connecting to %s:%d", self.options.hubhost, self.options.hubport) reactor.connectTCP(self.options.hubhost, self.options.hubport, factory) self.log.debug("Logging in as %s", self.options.username) c = credentials.UsernamePassword(self.options.username, self.options.password) factory.gotPerspective = self.gotPerspective def stop(*args): reactor.callLater(0, reactor.stop) factory.clientConnectionLost = stop factory.startLogin(c)
def __init__(self): signal.signal(signal.SIGUSR2, signal.SIG_IGN) ZCmdBase.__init__(self) if self.options.profiling: self.profiler = ContinuousProfiler('zenhubworker', log=self.log) self.profiler.start() self.current = IDLE self.currentStart = 0 self.numCalls = Metrology.meter("zenhub.workerCalls") try: self.log.debug("establishing SIGUSR1 signal handler") signal.signal(signal.SIGUSR1, self.sighandler_USR1) self.log.debug("establishing SIGUSR2 signal handler") signal.signal(signal.SIGUSR2, self.sighandler_USR2) except ValueError: # If we get called multiple times, this will generate an exception: # ValueError: signal only works in main thread # Ignore it as we've already set up the signal handler. pass self.zem = self.dmd.ZenEventManager loadPlugins(self.dmd) self.pid = os.getpid() self.services = {} factory = ReconnectingPBClientFactory(pingPerspective=False) self.log.debug("Connecting to %s:%d", self.options.hubhost, self.options.hubport) reactor.connectTCP(self.options.hubhost, self.options.hubport, factory) self.log.debug("Logging in as %s", self.options.username) c = credentials.UsernamePassword(self.options.username, self.options.password) factory.gotPerspective = self.gotPerspective def stop(*args): reactor.callLater(0, reactor.stop) factory.clientConnectionLost = stop factory.setCredentials(c) self.log.debug("Creating async MetricReporter") daemonTags = { 'zenoss_daemon': 'zenhub_worker_%s' % self.options.workernum, 'zenoss_monitor': self.options.monitor, 'internal': True } def stopReporter(): if self.metricreporter: return self.metricreporter.stop() # Order of the shutdown triggers matter. Want to stop reporter first, calling metricWriter() below # registers shutdown triggers for the actual metric http and redis publishers. reactor.addSystemEventTrigger('before', 'shutdown', stopReporter) self.metricreporter = TwistedMetricReporter( metricWriter=metricWriter(), tags=daemonTags) self.metricreporter.start()
def createDeviceProxy(self, dev, skipModelMsg=''): if self.plugins is None: self.plugins = {} for loader in loadPlugins(self.dmd): try: plugin = loader.create() plugin.loader = loader self.plugins[plugin.name()] = plugin except Exception as ex: log.exception(ex) result = DeviceProxy() result.id = dev.getId() result.skipModelMsg = skipModelMsg if not skipModelMsg: if not dev.manageIp: dev.setManageIp() result.manageIp = dev.manageIp result.plugins = [] for name in dev.zCollectorPlugins: plugin = self.plugins.get(name, None) log.debug('checking plugin %s for device %s' % (name, dev.getId())) if plugin and plugin.condition(dev, log): log.debug('adding plugin %s for device %s' % (name, dev.getId())) result.plugins.append(plugin.loader) plugin.copyDataToProxy(dev, result) result.temp_device = dev.isTempDevice() return result
def getModelerPluginDocStrings(self, uid): """ Returns a dictionary of documentation for modeler plugins, indexed by the plugin name. """ obj = self._getObject(uid) plugins = loadPlugins(obj) docs = {} packImporter = PackImporter() coreImporter = CoreImporter() for plugin in plugins: try: module = coreImporter.importModule(plugin.package, plugin.modPath) except ImportError: try: module = packImporter.importModule(plugin.package, plugin.modPath) except ImportError: # unable to import skip over this one continue pluginDocs = module.__doc__ if pluginDocs: pluginDocs = '<pre>' + pluginDocs.replace('\n', '\n<br/>') + '</pre>' docs[plugin.pluginName] = pluginDocs return docs
def __init__(self, reactor): """Initialize a ZenHubWorker instance.""" ZCmdBase.__init__(self) self.__reactor = reactor if self.options.profiling: self.profiler = ContinuousProfiler('ZenHubWorker', log=self.log) self.profiler.start() reactor.addSystemEventTrigger( 'before', 'shutdown', self.profiler.stop, ) self.instanceId = self.options.workerid self.current = IDLE self.currentStart = 0 self.numCalls = Metrology.meter("zenhub.workerCalls") self.zem = self.dmd.ZenEventManager loadPlugins(self.dmd) serviceFactory = ServiceReferenceFactory(self) self.__registry = HubServiceRegistry(self.dmd, serviceFactory) # Configure/initialize the ZenHub client creds = UsernamePassword( self.options.hubusername, self.options.hubpassword, ) endpointDescriptor = "tcp:{host}:{port}".format( host=self.options.hubhost, port=self.options.hubport, ) endpoint = clientFromString(reactor, endpointDescriptor) self.__client = ZenHubClient(reactor, endpoint, creds, self, 10.0) # Setup Metric Reporting self.log.debug("Creating async MetricReporter") self._metric_manager = MetricManager( daemon_tags={ 'zenoss_daemon': 'zenhub_worker_%s' % self.options.workerid, 'zenoss_monitor': self.options.monitor, 'internal': True, }, )
def createDeviceProxy(self, dev, skipModelMsg=''): if self.plugins is None: self.plugins = {} for loader in loadPlugins(self.dmd): try: plugin = loader.create() plugin.loader = loader self.plugins[plugin.name()] = plugin except Exception, ex: log.exception(ex)
def createDeviceProxy(self, dev, skipModelMsg=''): if self.plugins is None: self.plugins = {} for loader in loadPlugins(self.dmd): try: plugin = loader.create() plugin.loader = loader self.plugins[plugin.name()] = plugin except Exception, ex: log.warn("The following error occurred while loading %s plugin:\n %s"%(loader.modPath,ex)) if "ZenWin.WMIPlugin" in loader.modPath: log.info("Installing ZenPacks.zenoss.WindowsMonitor will likely resolve this issue.") log.info("See the install guide for details regarding the Windows Monitoring RPM.")
def makePluginRegistry(self, dmd): pluginPath = {} for loader in loadPlugins(dmd): try: plugin = loader.create() plugin.loader = loader # Note: can't return the actual plugin code because # zenhubworkers will puke with an import error # while unpickling the data. # ERROR zen.ZenHub: Error un-pickling result from worker path = loader.modPath if not path.startswith('ZenPack'): path = 'Products.DataCollector.plugins.' + path pluginPath[plugin.name()] = (path, plugin) except Exception: log.exception("Unable to load plugin '%s'", loader) return pluginPath
def createDeviceProxy(self, dev, skipModelMsg=''): if self.plugins is None: self.plugins = {} for loader in loadPlugins(self.dmd): try: plugin = loader.create() plugin.loader = loader self.plugins[plugin.name()] = plugin except Exception, ex: log.warn( "The following error occurred while loading %s plugin:\n %s" % (loader.modPath, ex)) if "ZenWin.WMIPlugin" in loader.modPath: log.info( "Installing ZenPacks.zenoss.WindowsMonitor will likely resolve this issue." ) log.info( "See the install guide for details regarding the Windows Monitoring RPM." )
def zenPropertyOptions(self, propname): """ Provide a set of default options for a zProperty @param propname: zProperty name @type propname: string @return: list of zProperty options @rtype: list """ if propname == 'zCollectorPlugins': from Products.DataCollector.Plugins import loadPlugins return sorted(ldr.pluginName for ldr in loadPlugins(self.dmd)) if propname == 'zCommandProtocol': return ['ssh', 'telnet'] if propname == 'zSnmpVer': return ['v1', 'v2c', 'v3'] if propname == 'zSnmpAuthType': return ['', 'MD5', 'SHA'] if propname == 'zSnmpPrivType': return ['', 'DES', 'AES'] return DeviceOrganizer.zenPropertyOptions(self, propname)
def __init__(self): """ Hook ourselves up to the Zeo database and wait for collectors to connect. """ # list of remote worker references self.workers = [] self.workTracker = {} # zenhub execution stats: # [count, idle_total, running_total, last_called_time] self.executionTimer = collections.defaultdict(lambda: [0, 0.0, 0.0, 0]) self.workList = _ZenHubWorklist() # set of worker processes self.worker_processes = set() # map of worker pids -> worker processes self.workerprocessmap = {} self.shutdown = False self.counters = collections.Counter() self._invalidations_paused = False wl = self.workList metricNames = {x[0] for x in registry} class EventWorkList(Gauge): @property def value(self): return len(wl.eventworklist) if 'zenhub.eventWorkList' not in metricNames: Metrology.gauge('zenhub.eventWorkList', EventWorkList()) class ADMWorkList(Gauge): @property def value(self): return len(wl.applyworklist) if 'zenhub.admWorkList' not in metricNames: Metrology.gauge('zenhub.admWorkList', ADMWorkList()) class OtherWorkList(Gauge): @property def value(self): return len(wl.otherworklist) if 'zenhub.otherWorkList' not in metricNames: Metrology.gauge('zenhub.otherWorkList', OtherWorkList()) class WorkListTotal(Gauge): @property def value(self): return len(wl) if 'zenhub.workList' not in metricNames: Metrology.gauge('zenhub.workList', WorkListTotal()) ZCmdBase.__init__(self) import Products.ZenHub load_config("hub.zcml", Products.ZenHub) notify(HubWillBeCreatedEvent(self)) if self.options.profiling: self.profiler = ContinuousProfiler('zenhub', log=self.log) self.profiler.start() # Worker selection handler self.workerselector = WorkerSelector(self.options) self.workList.log = self.log # make sure we don't reserve more than n-1 workers for events maxReservedEventsWorkers = 0 if self.options.workers: maxReservedEventsWorkers = self.options.workers - 1 if self.options.workersReservedForEvents > maxReservedEventsWorkers: self.options.workersReservedForEvents = maxReservedEventsWorkers self.log.info( "reduced number of workers reserved for sending events to %d", self.options.workersReservedForEvents) self.zem = self.dmd.ZenEventManager loadPlugins(self.dmd) self.services = {} er = HubRealm(self) checker = self.loadChecker() pt = portal.Portal(er, [checker]) interface = '::' if ipv6_available() else '' pbport = reactor.listenTCP(self.options.pbport, pb.PBServerFactory(pt), interface=interface) self.setKeepAlive(pbport.socket) xmlsvc = AuthXmlRpcService(self.dmd, checker) reactor.listenTCP(self.options.xmlrpcport, server.Site(xmlsvc), interface=interface) # responsible for sending messages to the queues import Products.ZenMessaging.queuemessaging load_config_override('twistedpublisher.zcml', Products.ZenMessaging.queuemessaging) notify(HubCreatedEvent(self)) self.sendEvent(eventClass=App_Start, summary="%s started" % self.name, severity=0) self._initialize_invalidation_filters() reactor.callLater(self.options.invalidation_poll_interval, self.processQueue) self._metric_writer = metricWriter() self.rrdStats = self.getRRDStats() if self.options.workers: self.workerconfig = zenPath( 'var', 'zenhub', '{}_worker.conf'.format(self._getConf().id)) self._createWorkerConf() for i in range(self.options.workers): self.createWorker(i) # start cyclic call to giveWorkToWorkers reactor.callLater(2, self.giveWorkToWorkers, True) # set up SIGUSR2 handling try: signal.signal(signal.SIGUSR2, self.sighandler_USR2) except ValueError: # If we get called multiple times, this will generate an exception: # ValueError: signal only works in main thread # Ignore it as we've already set up the signal handler. pass # ZEN-26671 Wait at least this duration in secs # before signaling a worker process self.SIGUSR_TIMEOUT = 5
def __init__(self, reactor): """Initialize a ZenHubWorker instance.""" ZCmdBase.__init__(self) self.__reactor = reactor if self.options.profiling: self.profiler = ContinuousProfiler('ZenHubWorker', log=self.log) self.profiler.start() reactor.addSystemEventTrigger( 'before', 'shutdown', self.profiler.stop, ) self.current = IDLE self.currentStart = 0 self.numCalls = Metrology.meter("zenhub.workerCalls") self.zem = self.dmd.ZenEventManager loadPlugins(self.dmd) self.__registry = ServiceRegistry() loader = ServiceLoader() factory = ServiceReferenceFactory(self) self.__manager = ServiceManager(self.__registry, loader, factory) # Configure/initialize the ZenHub client creds = UsernamePassword( self.options.hubusername, self.options.hubpassword, ) endpointDescriptor = "tcp:{host}:{port}".format( host=self.options.hubhost, port=self.options.hubport, ) endpoint = clientFromString(reactor, endpointDescriptor) self.__client = ZenHubClient( reactor, endpoint, creds, self, 10.0, self.worklistId, ) # Setup Metric Reporting self.log.debug("Creating async MetricReporter") self._metric_manager = MetricManager(daemon_tags={ 'zenoss_daemon': 'zenhub_worker_%s' % self.instanceId, 'zenoss_monitor': self.options.monitor, 'internal': True, }, ) # Make the metric manager available via zope.component.getUtility getGlobalSiteManager().registerUtility( self._metric_manager, IMetricManager, name='zenhub_worker_metricmanager', )