def __init__(self, noopts=0, args=None, should_log=None):
zope.component.provideAdapter(DefaultTraversable, (None, ))
# This explicitly loads all of the products - must happen first!
from OFS.Application import import_products
import_products()
#make sure we aren't in debug mode
import Globals
Globals.DevelopmentMode = False
# We must import ZenossStartup at this point so that all Zenoss daemons
# and tools will have any ZenPack monkey-patched methods available.
import Products.ZenossStartup
unused(Products.ZenossStartup)
zcml.load_site()
import Products.ZenWidgets
load_config_override('scriptmessaging.zcml', Products.ZenWidgets)
self.usage = "%prog [options]"
self.noopts = noopts
self.inputArgs = args
# inputArgs was created to allow unit tests to pass in command line
# arguments and get around whatever Zope was doing to sys.argv.
if self.inputArgs is None:
self.inputArgs = sys.argv[1:]
self.parser = None
self.args = []
self.buildParser()
self.buildOptions()
# Get defaults from global.conf. They will be overridden by
# daemon-specific config file or command line arguments.
applyGlobalConfToParser(self.parser)
self.parseOptions()
if self.options.configfile:
self.parser.defaults = self.getConfigFileDefaults(
self.options.configfile)
# We've updated the parser with defaults from configs, now we need
# to reparse our command-line to get the correct overrides from
# the command-line
self.parseOptions()
if should_log is not None:
self.doesLogging = should_log
if self.doesLogging:
self.setupLogging()
def __init__(self, noopts=0, args=None):
zope.component.provideAdapter(DefaultTraversable, (None,))
# This explicitly loads all of the products - must happen first!
from OFS.Application import import_products
import_products()
# make sure we aren't in debug mode
import Globals
Globals.DevelopmentMode = False
# We must import ZenossStartup at this point so that all Zenoss daemons
# and tools will have any ZenPack monkey-patched methods available.
import Products.ZenossStartup
unused(Products.ZenossStartup)
zcml.load_site()
import Products.ZenWidgets
load_config_override("scriptmessaging.zcml", Products.ZenWidgets)
self.usage = "%prog [options]"
self.noopts = noopts
self.inputArgs = args
# inputArgs was created to allow unit tests to pass in command line
# arguments and get around whatever Zope was doing to sys.argv.
if self.inputArgs is None:
self.inputArgs = sys.argv[1:]
self.parser = None
self.args = []
self.buildParser()
self.buildOptions()
# Get defaults from global.conf. They will be overridden by
# daemon-specific config file or command line arguments.
applyGlobalConfToParser(self.parser)
self.parseOptions()
if self.options.configfile:
self.parser.defaults = self.getConfigFileDefaults(self.options.configfile)
# We've updated the parser with defaults from configs, now we need
# to reparse our command-line to get the correct overrides from
# the command-line
self.parseOptions()
if self.doesLogging:
self.setupLogging()
def testSetUp(cls):
import Products
zope.component.testing.setUp(cls)
zope.component.provideAdapter(DefaultTraversable, (None,))
zcml.load_config('testing.zcml', Products.ZenTestCase)
import Products.ZenMessaging.queuemessaging
load_config_override('nopublisher.zcml', Products.ZenMessaging.queuemessaging)
# Have to force registering these as they are torn down between tests
from zenoss.protocols.adapters import registerAdapters
registerAdapters()
from twisted.python.runtime import platform
platform.supportsThreads_orig = platform.supportsThreads
platform.supportsThreads = lambda : None
def testSetUp(cls):
import Products
zope.component.testing.setUp(cls)
zope.component.provideAdapter(DefaultTraversable, (None,))
zcml.load_config('testing.zcml', Products.ZenTestCase)
import Products.ZenMessaging.queuemessaging
load_config_override('nopublisher.zcml', Products.ZenMessaging.queuemessaging)
# Have to force registering these as they are torn down between tests
from zenoss.protocols.adapters import registerAdapters
registerAdapters()
# Register Model Catalog related stuff
init_model_catalog_for_tests()
from twisted.python.runtime import platform
platform.supportsThreads_orig = platform.supportsThreads
platform.supportsThreads = lambda : None
def __init__(self):
"""
Hook ourselves up to the Zeo database and wait for collectors
to connect.
"""
self.shutdown = False
self.counters = collections.Counter()
super(ZenHub, self).__init__()
load_config("hub.zcml", ZENHUB_MODULE)
notify(HubWillBeCreatedEvent(self))
if self.options.profiling:
self.profiler = ContinuousProfiler('zenhub', log=self.log)
self.profiler.start()
self.zem = self.dmd.ZenEventManager
# responsible for sending messages to the queues
load_config_override('twistedpublisher.zcml', QUEUEMESSAGING_MODULE)
notify(HubCreatedEvent(self))
self.sendEvent(eventClass=App_Start,
summary="%s started" % self.name,
severity=0)
# ZenHub Services (and XMLRPC)
self._service_manager = HubServiceManager(
modeling_pause_timeout=self.options.modeling_pause_timeout,
passwordfile=self.options.passwordfile,
pbport=self.options.pbport,
xmlrpcport=self.options.xmlrpcport,
)
# Invalidation Processing
self._invalidation_manager = InvalidationManager(
self.dmd,
self.log,
self.async_syncdb,
self.storage.poll_invalidations,
self.sendEvent,
poll_interval=self.options.invalidation_poll_interval,
)
# Setup Metric Reporting
self._metric_manager = MetricManager(
daemon_tags={
'zenoss_daemon': 'zenhub',
'zenoss_monitor': self.options.monitor,
'internal': True
})
self._metric_writer = self._metric_manager.metric_writer
self.rrdStats = self._metric_manager.get_rrd_stats(
self._getConf(), self.zem.sendEvent
)
# 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):
self.shutdown = False
super(ZenHub, self).__init__()
load_config("hub.zcml", ZENHUB_MODULE)
notify(HubWillBeCreatedEvent(self))
if self.options.profiling:
self.profiler = ContinuousProfiler('zenhub', log=self.log)
self.profiler.start()
self.zem = self.dmd.ZenEventManager
# responsible for sending messages to the queues
load_config_override('twistedpublisher.zcml', QUEUEMESSAGING_MODULE)
notify(HubCreatedEvent(self))
self.sendEvent(eventClass=App_Start,
summary="%s started" % self.name,
severity=0)
# Initialize ZenHub's RPC servers
self._monitor = StatsMonitor()
self._status_reporter = ZenHubStatusReporter(self._monitor)
self._pools = make_pools()
self._service_manager = make_service_manager(self._pools)
authenticators = getCredentialCheckers(self.options.passwordfile)
self._server_factory = make_server_factory(
self._pools,
self._service_manager,
authenticators,
)
self._xmlrpc_manager = XmlRpcManager(self.dmd, authenticators[0])
register_legacy_worklist_metrics()
# Invalidation Processing
self._invalidation_manager = InvalidationManager(
self.dmd,
self.log,
self.async_syncdb,
self.storage.poll_invalidations,
self.sendEvent,
poll_interval=self.options.invalidation_poll_interval,
)
# Setup Metric Reporting
self._metric_manager = MetricManager(
daemon_tags={
'zenoss_daemon': 'zenhub',
'zenoss_monitor': self.options.monitor,
'internal': True,
})
provideUtility(self._metric_manager)
self._metric_writer = self._metric_manager.metric_writer
self.rrdStats = self._metric_manager.get_rrd_stats(
self._getConf(),
self.zem.sendEvent,
)
# set up SIGUSR2 handling
try:
signal.signal(signal.SIGUSR2, self.sighandler_USR2)
except ValueError as ex:
log.warn("Exception registering USR2 signal handler: %s", ex)
# 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):
"""
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
