def __init__(self, deviceId, taskName, scheduleIntervalSeconds, taskConfig, clientName=DEFAULT_JMX_JAVA_CLIENT_NAME ): super( ZenJMXTask, self ).__init__() self.name = taskName self.configId = deviceId self.state = TaskStates.STATE_IDLE self._taskConfig = taskConfig self._manageIp = self._taskConfig.manageIp self._dataService = zope.component.queryUtility( IDataService ) self._eventService = zope.component.queryUtility( IEventService ) self._preferences = zope.component.queryUtility( ICollectorPreferences, 'zenjmx' ) self._client = zope.component.queryUtility( IZenJMXJavaClient, clientName ) # At this time, do not use the interval passed from the device # configuration. Use the value pulled from the daemon # configuration. unused( scheduleIntervalSeconds ) self.interval = self._preferences.options.cycleInterval
def checkRaw(self, dataPoint, timeOf, value): """A new datapoint has been collected, use the given _raw_ value to re-evalue the threshold. returns a sequence of events. """ unused(timeOf, value) return self.check([dataPoint])
def getRRDCreateCommand(self, performanceConf): """Get the create command. Return '' for the default from performanceConf""" unused(performanceConf) if self.createCmd: return self.createCmd return ''
def objectItems(self, spec=None): """ ToManyRelationship doesn't publish objectItems to prevent zope recursion problems. """ unused(spec) return []
def countDevices(self, devrel="devices"): """count all devices with in a device group""" unused(devrel) count = self.devices.countObjects() for group in self.children(): count += group.countDevices() return count
def getGraphCmds(self, cmds, context, rrdDir, addSummary, idx, multiid=-1, prefix=''): ''' Build the graphing commands for this graphpoint ''' from Products.ZenUtils.Utils import unused unused(cmds, context, rrdDir, addSummary, idx, multiid, prefix) return cmds + ['COMMENT:%s' % self.text.replace(':', '\:')]
def getGraphElements(self, template, context, gopts, namespace, color, legend, relatedGps): """Produce a visual indication on the graph of where the threshold applies.""" unused(template, namespace) if not color.startswith('#'): color = '#%s' % color pointval = self.pointval if not self.dataPointNames: return gopts gp = relatedGps[self.dataPointNames[0]] # Attempt any RPN expressions rpn = getattr(gp, 'rpn', None) if rpn: try: rpn = talesEvalStr(rpn, context) except: self.raiseRPNExc() return gopts try: pointval = rpneval(pointval, rpn) except: pointval= 0 self.raiseRPNExc() result = [] if pointval: result += [ "COMMENT:%s(%s)\\j" % (self.SeverityString , pointval), ] log.warn(gopts + result) return gopts + result
def _getDeviceBatch(self, selectstatus='none', goodevids=[], badevids=[], offset=0, count=50, filter='', orderby='titleOrId', orderdir='asc'): unused(count, offset, orderby, orderdir) if not isinstance(goodevids, (list, tuple)): goodevids = [goodevids] if not isinstance(badevids, (list, tuple)): badevids = [badevids] if selectstatus=='all': idquery = ~In('id', badevids) else: idquery = In('id', goodevids) filter = '(?is).*%s.*' % filter filterquery = Or( MatchRegexp('id', filter), MatchRegexp('titleOrId', filter), MatchRegexp('getDeviceIp', filter), MatchRegexp('getProdState', filter), MatchRegexp('getDeviceClassPath', filter) ) query = Eq('getPhysicalPath', self.context.absolute_url_path()) & idquery query = query & filterquery catalog = getattr(self.context, self.context.default_catalog) objects = catalog.evalAdvancedQuery(query) return [x['id'] for x in objects]
def manage_editOSProcessClass(self, name="", zMonitor=True, zAlertOnRestart=False, zFailSeverity=3, regex="", description="", ignoreParametersWhenModeling=False, ignoreParameters=False, REQUEST=None): """ Edit a ProductClass from a web page. """ from Products.ZenUtils.Utils import unused unused(zAlertOnRestart, zFailSeverity, zMonitor) # Left in name, added title for consistency self.title = name self.name = name id = self.prepId(name) redirect = self.rename(id) self.regex = regex self.description = description self.ignoreParametersWhenModeling = ignoreParametersWhenModeling self.ignoreParameters = ignoreParameters if REQUEST: from Products.ZenUtils.Time import SaveMessage messaging.IMessageSender(self).sendToBrowser( 'Product Class Saved', SaveMessage() ) return self.callZenScreen(REQUEST, redirect)
def loadObjectFromXML(self, objstack=None, xmlfile=""): """This method can be used to load data for the root of Zenoss (default behavior) or it can be used to operate on a specific point in the Zenoss hierarchy (ZODB). Upon loading the XML file to be processed, the content of the XML file is handled (processed) by the methods in this class. """ from Products.ZenUtils.Utils import unused unused(objstack) if xmlfile: # check to see if we're getting the XML from a URL ... schema, host, path, null, null, null = urlparse(xmlfile) if schema and host: self.infile = urllib2.urlopen(xmlfile) # ... or from a file on the file system else: self.infile = open(xmlfile) elif self.options.infile: self.infile = open(self.options.infile) else: self.infile = sys.stdin self.doc = parse(self.infile) self.handleDevices() self.doc.unlink() self.infile.close()
def getGraphCmds(self, cmds, context, rrdDir, addSummary, idx, multiid=-1, prefix=''): ''' Build the graphing commands for this graphpoint ''' from Products.ZenUtils.Utils import unused unused(multiid, prefix, rrdDir) return cmds
def wrapper(*args, **kwargs): try: import ZenPacks.zenoss.Impact unused(ZenPacks.zenoss.Impact) except ImportError: return return f(*args, **kwargs)
def remote_updateDeviceList(self, devices): """ Callable from zenhub. @param devices: list of devices (unused) @type devices: list """ unused(devices) self.log.debug("Async update of device list")
def redirectToUserCommands(self, REQUEST, commandId=None): ''' Redirect to the page which lists UserCommands for this Commandable object. ''' unused(commandId) url = self.getUrlForUserCommands() if url: return REQUEST.RESPONSE.redirect(url) return self.callZenScreen(REQUEST)
def _getOb(self, id, default=zenmarker): """ Return object by id if it exists on this relationship. If it doesn't exist return default or if default is not set raise AttributeError """ unused(default) if True: raise NotImplementedError
def manage_addAdministrativeRole(self, name=None, type='device', role=None, guid=None, uid=None, REQUEST=None): "Add a Admin Role to the passed object" unused(role) mobj = None if guid or uid: # look up our object by either guid or uid if guid: manager = IGUIDManager(self.dmd) mobj = manager.getObject(guid) elif uid: mobj = self.unrestrictedTraverse(uid) else: # use magic to look up our object if not name: name = REQUEST.deviceName if type == 'device': mobj =self.getDmdRoot("Devices").findDevice(name) else: try: root = type.capitalize()+'s' if type == "deviceClass": mobj = self.getDmdRoot("Devices").getOrganizer(name) else: mobj = self.getDmdRoot(root).getOrganizer(name) except KeyError: pass if not mobj: if REQUEST: messaging.IMessageSender(self).sendToBrowser( 'Error', "%s %s not found"%(type.capitalize(),name), priority=messaging.WARNING ) return self.callZenScreen(REQUEST) else: return roleNames = [ r.id for r in mobj.adminRoles() ] if self.id in roleNames: if REQUEST: messaging.IMessageSender(self).sendToBrowser( 'Error', (("Administrative Role for %s %s " "for user %s already exists.") % (type, name, self.id)), priority=messaging.WARNING ) return self.callZenScreen(REQUEST) else: return mobj.manage_addAdministrativeRole(self.id) if REQUEST: messaging.IMessageSender(self).sendToBrowser( 'Role Added', ("Administrative Role for %s %s for user %s added" % (type, name, self.id)) ) audit('UI.User.AddAdministrativeRole', username=self.id, data_={mobj.meta_type:mobj.getPrimaryId()}) return self.callZenScreen(REQUEST)
def children(self, sort=False, checkPerm=True, spec=None): ''' Return all objects that are instances of ReportClass ''' unused(spec) kids = [o for o in self.objectValues() if isinstance(o, ReportClass)] if checkPerm: kids = [kid for kid in kids if self.checkRemotePerm("View", kid)] if sort: kids.sort(key=lambda x: x.primarySortKey()) return kids
def check(self, dataPoints): """The given datapoints have been updated, so re-evaluate. returns events or an empty sequence""" unused(dataPoints) result = [] for dp in self.dataPointNames: cycleTime, rrdType = self._getRRDType(dp) result.extend(self._checkImpl( dp, self._fetchLastValue(dp, cycleTime))) return result
def check(self, dataPoints): """The given datapoints have been updated, so re-evaluate. returns events or an empty sequence""" unused(dataPoints) result = [] for dp in self.dataPointNames: cycleTime, rrdType = self.rrdInfoCache(dp) result.extend(self.checkDuration( dp, self.fetchValuesList(dp, self.interval))) return result
def check(self, dataPoint): """The given datapoints have been updated, so re-evaluate. returns events or an empty sequence""" unused(dataPoint) result = [] for dp in self.dataPointNames: cycleTime, rrdType = self.rrdInfoCache(dp) result.extend(self.checkStatus( dp, self.fetchLastValue(dp, cycleTime))) return result
def getGraphCmds(self, cmds, context, rrdDir, addSummary, idx, multiid=-1, prefix=''): ''' Build the graphing commands for this graphpoint ''' from Products.ZenUtils.Utils import unused unused(multiid, rrdDir) return cmds + ['PRINT:%s:%s%s' % ( self.addPrefix(prefix, self.vname), (self.format or self.DEFAULT_FORMAT).replace(':', '\:'), self.strftime and ':%s' % self.strftime or '')]
def _delObject(self, id, dp=1, suppress_events=False): """Emulate ObjectManager deletetion.""" unused(dp) obj = self._getOb(id, False) if not obj: log.warning( "Tried to delete object id '%s' but didn't find it on %s", id, self.getPrimaryId()) return self.removeRelation(obj, suppress_events) obj.__primary_parent__ = None
def getGraphCmds(self, cmds, context, rrdDir, addSummary, idx, multiid=-1, prefix=''): ''' Build the graphing commands for this graphpoint ''' from Products.ZenUtils.Utils import unused unused(rrdDir) if not self.rpn: return cmds rpn = self.talesEval(self.rpn, context) return cmds + ['CDEF:%s=%s' % ( self.getDsName(self.id, multiid, prefix), self.getRpn(multiid, prefix))]
def enrich(self, event, subject): """ Sanitize the event facility and severity fields. @param event: event @type event: simple class @param subject: e-mail subject (unused) @type subject: string """ unused(subject) event.facility = "unknown" event.severity = self.eventSeverity
def clientConnectionFailed(self, connector, reason): """ If we don't connect let the modeler know @param connector: unused (unused) @type connector: unused @param reason: error message to report @type reason: string """ unused(connector) log.warn(reason.getErrorMessage()) self.clientFinished()
def _load_modules(): # Due to the manipulation of sys.path during the loading of plugins, # we can get ObjectMap imported both as DataMaps.ObjectMap and the # full-path from Products. The following gets the class registered # with the jelly serialization engine under both names: # 1st: get Products.DataCollector.plugins.DataMaps.ObjectMap from Products.DataCollector.plugins.DataMaps import ObjectMap # 2nd: get DataMaps.ObjectMap sys.path.insert(0, zenPath('Products', 'DataCollector', 'plugins')) import DataMaps unused(DataMaps, ObjectMap)
def getGraphCmds(self, cmds, context, rrdDir, addSummary, idx, multiid=-1, prefix=''): ''' Build the graphing commands for this graphpoint ''' from Products.ZenUtils.Utils import unused unused(multiid, prefix, rrdDir) legend = self.talesEval(self.legend, context) legend = self.escapeForRRD(legend) return cmds + ['HRULE:%s%s%s' % ( self.value or 0, self.getColor(idx), legend and ':%s' % legend or '')]
def manage_addCollectionItem(context, id, deviceId, compPath, sequence, REQUEST = None): ''' This is here so than zope will let us copy/paste/rename CollectionItems. ''' unused(deviceId, compPath, sequence) ci = CollectionItem(id) context._setObject(id, ci) ci.deviceId = deviceId ci.compPath = compPath ci.sequence = sequence if REQUEST is not None: return REQUEST['RESPONSE'].redirect(context.absolute_url_path() +'/manage_main')
def getAllCounts(self, devrel=None): """Count all devices within a device group and get the ping and snmp counts as well""" unused(devrel) counts = [ self.ipaddresses.countObjects(), self._status("Ping", "ipaddresses"), self._status("Snmp", "ipaddresses"), ] for group in self.children(): sc = group.getAllCounts() for i in range(3): counts[i] += sc[i] return counts
def _startMaintenance(self, ignored=None): unused(ignored) if not self.options.cycle: self._maintenanceCycle() return if self.options.logTaskStats > 0: log.debug("Starting Task Stat logging") loop = task.LoopingCall(self._displayStatistics, verbose=True) loop.start(self.options.logTaskStats, now=False) interval = self.preferences.cycleInterval self.log.debug("Initializing maintenance Cycle") maintenanceCycle = MaintenanceCycle(interval, self, self._maintenanceCycle) maintenanceCycle.start()
def __init__(self, id, title=None, buildRelations=True): unused(title) self.id = id if buildRelations: self.buildRelations()
IEventService,\ IScheduledTask from Products.ZenCollector.tasks import SimpleTaskFactory,\ SimpleTaskSplitter,\ TaskStates, \ BaseTask from Products.ZenEvents.ZenEventClasses import Status_Snmp from Products.ZenEvents import Event # We retrieve our configuration data remotely via a Twisted PerspectiveBroker # connection. To do so, we need to import the class that will be used by the # configuration service to send the data over, i.e. SnmpDeviceProxy. from Products.ZenUtils.Utils import unused from Products.ZenHub.services.SnmpPerformanceConfig import SnmpDeviceProxy unused(SnmpDeviceProxy) from Products.ZenHub.services.PerformanceConfig import SnmpConnInfo unused(SnmpConnInfo) COLLECTOR_NAME = "zenperfsnmp" MAX_BACK_OFF_MINUTES = 20 class SnmpPerformanceCollectionPreferences(object): zope.interface.implements(ICollectorPreferences) def __init__(self): """ Constructs a new SnmpPerformanceCollectionPreferences instance and provides default values for needed attributes. """
from Products.ZenCollector.daemon import CollectorDaemon from Products.ZenCollector.interfaces \ import ICollectorPreferences, IScheduledTask, IEventService, IDataService from Products.ZenCollector.tasks \ import SimpleTaskFactory, SimpleTaskSplitter, TaskStates from Products.ZenUtils.observable import ObservableMixin from Products.ZenUtils.Utils import unused from ZenPacks.itri.PowerConsumptionMonitor.services.PowerMonConfigService \ import PowerMonConfigService unused(Globals) unused(PowerMonConfigService) from Products.ZenEvents.ZenEventClasses import Error, Clear, Critical class ZenPowerConsumptionMonitorPreferences(object): zope.interface.implements(ICollectorPreferences) def __init__(self): self.collectorName = 'powercond' self.configurationService = \ "ZenPacks.itri.PowerConsumptionMonitor.services.PowerMonConfigService" # How often the daemon will collect each device. Specified in seconds. self.cycleInterval = 1 * 60
def buildOptions(self, parser): unused(self, parser) pass
def __init__(self, noopts=0, app=None, keeproot=False): ZenDaemon.__init__(self, noopts, keeproot) unused(app) self.opendb() self.openconn = self.getPoolSize()
def generate_xml_table(self, parser, options): """ Create a Docbook table based on the long-form of the option names @parameter parser: an optparse parser object which contains defaults, help @parameter options: parsed options list containing actual values """ # # Header for the configuration file # unused(options) daemon_name = os.path.basename(sys.argv[0]) daemon_name = daemon_name.replace('.py', '') print """<?xml version="1.0" encoding="UTF-8"?> <section version="4.0" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:html="http://www.w3.org/1999/xhtml" xmlns:db="http://docbook.org/ns/docbook" xml:id="%s.options" > <title>%s Options</title> <para /> <table frame="all"> <caption>%s <indexterm><primary>Daemons</primary><secondary>%s</secondary></indexterm> options</caption> <tgroup cols="2"> <colspec colname="option" colwidth="1*" /> <colspec colname="description" colwidth="2*" /> <thead> <row> <entry> <para>Option</para> </entry> <entry> <para>Description</para> </entry> </row> </thead> <tbody> """ % (daemon_name, daemon_name, daemon_name, daemon_name) options_to_ignore = ('help', 'version', '', 'genconf', 'genxmltable') # # Create an entry for each of the command line flags # # NB: Ideally, this should print out only the option parser dest # entries, rather than the command line options. # import re for opt in getAllParserOptionsGen(parser): if opt.help is SUPPRESS_HELP: continue # # Create a Docbook-happy version of the option strings # Yes, <arg></arg> would be better semantically, but the output # just looks goofy in a table. Use literal instead. # all_options = '<literal>' + re.sub( r'/', '</literal>,</para> <para><literal>', "%s" % opt) + '</literal>' # # Don't display anything we shouldn't be displaying # option_name = re.sub(r'.*/--', '', "%s" % opt) option_name = re.sub(r'^--', '', "%s" % option_name) if option_name in options_to_ignore: continue default_value = parser.defaults.get(opt.dest) if default_value is NO_DEFAULT or default_value is None: default_value = "" default_string = "" if default_value != "": default_string = "<para> Default: <literal>" + str( default_value) + "</literal></para>\n" comment = self.pretty_print_config_comment(opt.help) # # TODO: Determine the variable name used and display the --option_name=variable_name # if opt.action in ['store_true', 'store_false']: print """<row> <entry> <para>%s</para> </entry> <entry> <para>%s</para> %s</entry> </row> """ % (all_options, comment, default_string) else: target = '=<replaceable>' + opt.dest.lower() + '</replaceable>' all_options = all_options + target all_options = re.sub(r',', target + ',', all_options) print """<row> <entry> <para>%s</para> </entry> <entry> <para>%s</para> %s</entry> </row> """ % (all_options, comment, default_string) # # Close the table elements # print """</tbody></tgroup> </table> <para /> </section> """ sys.exit(0)
# License.zenoss under the directory where your Zenoss product is installed. # ############################################################################## import Globals from Products.DataCollector.Plugins import loadPlugins from Products.ZenHub import PB_PORT from Products.ZenHub.zenhub import LastCallReturnValue from Products.ZenHub.PBDaemon import translateError, RemoteConflictError from Products.ZenUtils.Time import isoDateTime from Products.ZenUtils.ZCmdBase import ZCmdBase from Products.ZenUtils.Utils import unused, zenPath from Products.ZenUtils.PBUtil import ReconnectingPBClientFactory # required to allow modeling with zenhubworker from Products.DataCollector.plugins import DataMaps unused(DataMaps) from twisted.cred import credentials from twisted.spread import pb from twisted.internet import defer, reactor, error from ZODB.POSException import ConflictError from collections import defaultdict import cPickle as pickle import time import signal import os IDLE = "None/None"
def _setOb(self, id, obj): """don't use attributes in relations""" unused(id) unused(obj) if True: raise NotImplementedError
def snmpStatus(self, devrel=None): """aggregate snmp status for all devices in this group and below""" unused(devrel) return DeviceOrganizer.snmpStatus(self, "ipaddresses")
from zope.event import notify from zExceptions import BadRequest from ZPublisher.Converters import type_converters from Products.ZenModel.interfaces import IDeviceLoader from Products.ZenUtils.ZCmdBase import ZCmdBase from Products.ZenModel.Device import Device from Products.ZenRelations.ZenPropertyManager import iszprop from Products.ZenModel.ZenModelBase import iscustprop from Products.ZenEvents.ZenEventClasses import Change_Add from Products.Zuul.catalog.events import IndexingEvent from Products.ZenUtils.Utils import unused # We import DateTime so that we can set properties of type DateTime in the batchload from DateTime import DateTime unused(DateTime) from Products.ZenUtils.IpUtil import isip from zenoss.protocols.protobufs.zep_pb2 import SEVERITY_INFO, SEVERITY_ERROR class BatchDeviceLoader(ZCmdBase): """ Base class wrapping around dmd.DeviceLoader """ # ZEN-9930 - Pulled these options from sample config # setHWProduct=('myproductName','manufacturer'), setOSProduct=('OS Name','manufacturer') sample_configs = """# # Example zenbatchloader file (Groups, Systems Locations, Devices, etc.)
def zenPropertyOptions(self, propname): """Provide a set of default options for a ZProperty. """ unused(propname) return []
$Id: SQLClient.py,v 2.19 2011/12/29 23:40:12 egor Exp $""" __version__ = "$Revision: 2.19 $"[11:-2] import Globals from Products.ZenUtils.Utils import zenPath, unused from Products.ZenUtils.Driver import drive from Products.DataCollector.BaseClient import BaseClient from twisted.enterprise import adbapi from twisted.internet import defer from twisted.python.failure import Failure from pysamba.wbem.Query import Query unused(Query) import datetime import decimal from DateTime import DateTime import re DTPAT = re.compile( r'^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})\.(\d{6})([+|-])(\d{3})') import os import sys import logging log = logging.getLogger("zen.SQLClient")
from Products.ZenRRD import runner from Products.ZenCollector.daemon import CollectorDaemon from Products.ZenCollector.interfaces import ICollectorPreferences,\ IDataService,\ IEventService,\ IScheduledTask from Products.ZenCollector.tasks import SimpleTaskFactory,\ SubConfigurationTaskSplitter,\ TaskStates, \ BaseTask from Products.ZenEvents import Event from Products.ZenUtils.Executor import TwistedExecutor from Products.DataCollector import Plugins unused(Plugins) MAX_CONNECTIONS = 250 MAX_BACK_OFF_MINUTES = 20 # We retrieve our configuration data remotely via a Twisted PerspectiveBroker # connection. To do so, we need to import the class that will be used by the # configuration service to send the data over, i.e. DeviceProxy. from Products.ZenCollector.services.config import DeviceProxy unused(DeviceProxy) # The following classes were refactored into the runner module after the # 4.2 release. ZenPacks were importing those classes from here, so they # must be exported for backwards compatibility. ProcessRunner = runner.ProcessRunner ProcessRunner.start = ProcessRunner.send
IStatisticsService from Products.ZenCollector.tasks import SimpleTaskFactory,\ SimpleTaskSplitter,\ TaskStates from Products.ZenEvents.ZenEventClasses import Clear, Error, Warning, Info, \ Debug, Status_Wmi from Products.ZenUtils.observable import ObservableMixin from ZenPacks.zenoss.WindowsMonitor.Watcher import Watcher from ZenPacks.zenoss.WindowsMonitor.utils import addNTLMv2Option, setNTLMv2Auth # We retrieve our configuration data remotely via a Twisted PerspectiveBroker # connection. To do so, we need to import the class that will be used by the # configuration service to send the data over, i.e. DeviceProxy. from Products.ZenUtils.Utils import unused from Products.ZenCollector.services.config import DeviceProxy unused(DeviceProxy) from ZenPacks.zenoss.WindowsMonitor.services.EventLogConfig import EventLogConfig unused(EventLogConfig) # # creating a logging context for this module to use # log = logging.getLogger("zen.zeneventlog") # Create an implementation of the ICollectorPreferences interface so that the # ZenCollector framework can configure itself from our preferences. class ZenEventLogPreferences(object): zope.interface.implements(ICollectorPreferences) def __init__(self):
def _notifyOfCopyTo(self, container, op=0): """Manage copy/move/rename state for use in manage_beforeDelete.""" unused(container) self._operation = op # 0 == copy, 1 == move, 2 == rename
def generate_configs(self, parser, options): """ Create a configuration file based on the long-form of the option names @parameter parser: an optparse parser object which contains defaults, help @parameter options: parsed options list containing actual values """ # # Header for the configuration file # unused(options) daemon_name = os.path.basename(sys.argv[0]) daemon_name = daemon_name.replace('.py', '') print """# # Configuration file for %s # # To enable a particular option, uncomment the desired entry. # # Parameter Setting # --------- -------""" % (daemon_name) options_to_ignore = ('help', 'version', '', 'genconf', 'genxmltable') # # Create an entry for each of the command line flags # # NB: Ideally, this should print out only the option parser dest # entries, rather than the command line options. # import re for opt in getAllParserOptionsGen(parser): if opt.help is SUPPRESS_HELP: continue # # Get rid of the short version of the command # option_name = re.sub(r'.*/--', '', "%s" % opt) # # And what if there's no short version? # option_name = re.sub(r'^--', '', "%s" % option_name) # # Don't display anything we shouldn't be displaying # if option_name in options_to_ignore: continue # # Find the actual value specified on the command line, if any, # and display it # value = getattr(parser.values, opt.dest) default_value = parser.defaults.get(opt.dest) if default_value is NO_DEFAULT or default_value is None: default_value = "" default_string = "" if default_value != "": default_string = ", default: " + str(default_value) comment = self.pretty_print_config_comment(opt.help + default_string) # # NB: I would prefer to use tabs to separate the parameter name # and value, but I don't know that this would work. # print """# # %s #%s %s""" % (comment, option_name, value) # # Pretty print and exit # print "#" sys.exit(0)
def generate_xml_configs(self, parser, options): """ Create an XML file that can be used to create Docbook files as well as used as the basis for GUI-based daemon option configuration. """ # # Header for the configuration file # unused(options) daemon_name = os.path.basename(sys.argv[0]) daemon_name = daemon_name.replace('.py', '') export_date = datetime.datetime.now() print """<?xml version="1.0" encoding="UTF-8"?> <!-- Default daemon configuration generated on %s --> <configuration id="%s" > """ % (export_date, daemon_name) options_to_ignore = ( 'help', 'version', '', 'genconf', 'genxmltable', 'genxmlconfigs', ) # # Create an entry for each of the command line flags # # NB: Ideally, this should print out only the option parser dest # entries, rather than the command line options. # import re for opt in getAllParserOptionsGen(parser): if opt.help is SUPPRESS_HELP: continue # # Don't display anything we shouldn't be displaying # option_name = re.sub(r'.*/--', '', "%s" % opt) option_name = re.sub(r'^--', '', "%s" % option_name) if option_name in options_to_ignore: continue default_value = parser.defaults.get(opt.dest) if default_value is NO_DEFAULT or default_value is None: default_string = "" else: default_string = str(default_value) # # TODO: Determine the variable name used and display the --option_name=variable_name # if opt.action in ['store_true', 'store_false']: print """ <option id="%s" type="%s" default="%s" help="%s" /> """ % ( option_name, "boolean", default_string, quote(opt.help), ) else: target = opt.dest.lower() print """ <option id="%s" type="%s" default="%s" target="%s" help="%s" /> """ % ( option_name, opt.type, quote(default_string), target, quote(opt.help), ) # # Close the table elements # print """ </configuration> """ sys.exit(0)
import Globals import zope.interface import zope.component from zope.event import notify from Products.ZenCollector import daemon from Products.ZenCollector import interfaces from Products.ZenCollector import tasks from Products.ZenUtils import IpUtil import Products.ZenStatus.interfaces # perform some imports to allow twisted's PB to serialize these objects from Products.ZenUtils.Utils import unused from Products.ZenCollector.services.config import DeviceProxy from Products.ZenHub.services.PingPerformanceConfig import PingPerformanceConfig unused(DeviceProxy) unused(PingPerformanceConfig) from .interfaces import IParserReadyForOptionsEvent # define some constants strings COLLECTOR_NAME = "zenping" CONFIG_SERVICE = 'Products.ZenHub.services.PingPerformanceConfig' class ParserReadyForOptionsEvent(object): zope.interface.implements(IParserReadyForOptionsEvent) def __init__(self, parser): self.parser = parser
from twisted.python.failure import Failure from twisted.internet import defer import Globals from zope import interface from zope import component from zenoss.protocols.protobufs.zep_pb2 import SEVERITY_CLEAR from Products.ZenCollector import interfaces from Products.ZenCollector.tasks import TaskStates, BaseTask from Products.ZenUtils.Utils import unused from Products.ZenCollector.services.config import DeviceProxy unused(DeviceProxy) from Products.ZenEvents.ZenEventClasses import Status_Ping from Products.ZenEvents import ZenEventClasses from zenoss.protocols.protobufs import zep_pb2 as events from Products.ZenUtils.IpUtil import ipunwrap from interfaces import IPingTask COLLECTOR_NAME = "zenping" STATUS_EVENT = { 'eventClass': Status_Ping, 'component': 'zenping', ' eventGroup': 'Ping' }
from Products.ZenEvents import Event from Products.ZenCollector.daemon import CollectorDaemon from Products.ZenCollector.interfaces import ICollectorPreferences,\ IDataService,\ IEventService,\ IScheduledTask from Products.ZenCollector.tasks import SimpleTaskFactory,\ SubConfigurationTaskSplitter,\ TaskStates,\ BaseTask # do not delete this: it is needed for pb/jelly from Products.ZenUtils.Utils import unused from ZenPacks.zenoss.ZenMailTx.MailTxConfigService import Config unused(Config) COLLECTOR_NAME = "zenmailtx" log = logging.getLogger("zen.%s" % COLLECTOR_NAME) MAX_BACK_OFF_MINUTES = 20 mailEventClass = '/Status' class MailTxCollectionPreferences(object): implements(ICollectorPreferences) def __init__(self): """ Constructs a new preferences instance and
Option, SUPPRESS_HELP, NO_DEFAULT, OptionValueError, BadOptionError, ) from urllib import quote # There is a nasty incompatibility between pkg_resources and twisted. # This pkg_resources import works around the problem. # See http://dev.zenoss.org/trac/ticket/3146 for details from Products.ZenUtils.PkgResources import pkg_resources from Products.ZenUtils.Utils import unused, load_config_override, zenPath, getAllParserOptionsGen from Products.ZenUtils.GlobalConfig import _convertConfigLinesToArguments, applyGlobalConfToParser unused(pkg_resources) class DMDError: pass def checkLogLevel(option, opt, value): if re.match(r'^\d+$', value): value = int(value) else: intval = getattr(logging, value.upper(), None) if intval: value = intval else: raise OptionValueError('"%s" is not a valid log level.' % value)
# This content is made available according to terms specified in # License.zenoss under the directory where your Zenoss product is # installed. # ###################################################################### import logging LOG = logging.getLogger('zen.XenServer') import Globals from Products.ZenModel.ZenPack import ZenPack as ZenPackBase from Products.ZenRelations.zPropertyCategory import setzPropertyCategory from Products.ZenUtils.Utils import unused unused(Globals) ZENPACK_NAME = 'ZenPacks.zenoss.XenServer' # Modules containing model classes. Used by zenchkschema to validate # bidirectional integrity of defined relationships. productNames = ( 'Endpoint', 'Host', 'HostCPU', 'Network', 'PBD', 'PIF', 'Pool', 'SR', 'VBD',
def postStartup(self): unused(self) pass
IEventService, \ IScheduledTask, IStatisticsService from Products.ZenCollector.tasks import SimpleTaskFactory,\ SimpleTaskSplitter,\ BaseTask, TaskStates from Products.ZenUtils.observable import ObservableMixin from Products.ZenEvents.SyslogProcessing import SyslogProcessor from Products.ZenUtils.Utils import zenPath from Products.ZenUtils.IpUtil import asyncNameLookup from Products.ZenEvents.EventServer import Stats from Products.ZenUtils.Utils import unused from Products.ZenCollector.services.config import DeviceProxy unused(Globals, DeviceProxy) COLLECTOR_NAME = 'zensyslog' log = logging.getLogger("zen.%s" % COLLECTOR_NAME) class SyslogPreferences(object): zope.interface.implements(ICollectorPreferences) def __init__(self): """ Constructs a new PingCollectionPreferences instance and provides default values for needed attributes. """ self.collectorName = COLLECTOR_NAME self.configCycleInterval = 20 # minutes
def cleanup(self): unused(self) pass
from Products.ZenModel.Device import Device from Products.ZenModel.ZenStatus import ZenStatus from Products.ZenRelations.RelationshipBase import RelationshipBase from Products.ZenRelations.ToManyContRelationship import ToManyContRelationship from Products.ZenUtils.Utils import unused from Products.ZenUtils.ZenScriptBase import ZenScriptBase from time import localtime, strftime try: from ZenPacks.zenoss.AdvancedSearch.SearchManager import SearchManager, SEARCH_MANAGER_ID except ImportError: pass from ZenToolboxUtils import inline_print from ZODB.POSException import POSKeyError from ZODB.utils import u64 unused(Globals) def progress_bar(items, errors, repairs, fix_value, cycle): if fix_value: inline_print( "[%s] Cycle %s | Items Scanned: %12d | Errors: %6d | Repairs: %6d | " % (time.strftime("%Y-%m-%d %H:%M:%S"), cycle, items, errors, repairs)) else: inline_print( "[%s] Cycle %s | Items Scanned: %12d | Errors: %6d | " % (time.strftime("%Y-%m-%d %H:%M:%S"), cycle, items, errors)) class Fixer(object):
IScheduledTask from Products.ZenCollector.tasks import SimpleTaskFactory,\ SimpleTaskSplitter,\ TaskStates from Products.ZenEvents.ZenEventClasses import Error, Clear, Status_WinService, Status_Wmi from Products.ZenUtils.observable import ObservableMixin from ZenPacks.zenoss.WindowsMonitor.WMIClient import WMIClient from ZenPacks.zenoss.WindowsMonitor.Watcher import Watcher from ZenPacks.zenoss.WindowsMonitor.utils import addNTLMv2Option, setNTLMv2Auth # We retrieve our configuration data remotely via a Twisted PerspectiveBroker # connection. To do so, we need to import the class that will be used by the # configuration service to send the data over, i.e. DeviceProxy. from Products.ZenUtils.Utils import unused from Products.ZenCollector.services.config import DeviceProxy unused(DeviceProxy) from ZenPacks.zenoss.WindowsMonitor.services.WinServiceConfig import WinServiceConfig unused(WinServiceConfig) # # creating a logging context for this module to use # log = logging.getLogger("zen.zenwin") # Create an implementation of the ICollectorPreferences interface so that the # ZenCollector framework can configure itself from our preferences. class ZenWinPreferences(object): zope.interface.implements(ICollectorPreferences) def __init__(self):
def getGraphElements(self, template, context, gopts, namespace, color, legend, relatedGps): """Produce a visual indication on the graph of where the threshold applies.""" unused(template, namespace) if not color.startswith('#'): color = '#%s' % color minval = self.minimum if minval is None or minval == '': minval = NaN maxval = self.maximum if maxval is None or maxval == '': maxval = NaN if not self.dataPointNames: return gopts gp = relatedGps[self.dataPointNames[0]] # Attempt any RPN expressions rpn = getattr(gp, 'rpn', None) if rpn: try: rpn = talesEvalStr(rpn, context) except: self.raiseRPNExc() return gopts try: minval = rpneval(minval, rpn) except: minval = 0 self.raiseRPNExc() try: maxval = rpneval(maxval, rpn) except: maxval = 0 self.raiseRPNExc() minstr = self.setPower(minval) maxstr = self.setPower(maxval) minval = nanToNone(minval) maxval = nanToNone(maxval) if legend: gopts.append("HRULE:%s%s:%s\\j" % (minval or maxval, color, legend)) elif minval is not None and maxval is not None: if minval == maxval: gopts.append( "HRULE:%s%s:%s not equal to %s\\j" % (minval, color, self.getNames(relatedGps), minstr)) elif minval < maxval: gopts.append( "HRULE:%s%s:%s not within %s and %s\\j" % (minval, color, self.getNames(relatedGps), minstr, maxstr)) gopts.append("HRULE:%s%s" % (maxval, color)) elif minval > maxval: gopts.append( "HRULE:%s%s:%s between %s and %s\\j" % (minval, color, self.getNames(relatedGps), maxstr, minstr)) gopts.append("HRULE:%s%s" % (maxval, color)) elif minval is not None: gopts.append("HRULE:%s%s:%s less than %s\\j" % (minval, color, self.getNames(relatedGps), minstr)) elif maxval is not None: gopts.append("HRULE:%s%s:%s greater than %s\\j" % (maxval, color, self.getNames(relatedGps), maxstr)) return gopts
from Products.DataCollector.zenmodeler import ZenModeler from Products.ZenEvents.Event import Info from Products.ZenEvents.ZenEventClasses import Status_Snmp from Products.ZenHub.PBDaemon import FakeRemote, PBDaemon from Products.ZenHub.services import DiscoverService, ModelerService from Products.ZenHub.services.DiscoverService import JobPropertiesProxy from Products.ZenModel.Exceptions import NoIPAddress from Products.ZenStatus.nmap.util import executeNmapForIps from Products.ZenUtils.Exceptions import ZentinelException from Products.ZenUtils.IpUtil import (asyncNameLookup, isip, parse_iprange, getHostByName, ipunwrap) from Products.ZenUtils.snmp import (SnmpAgentDiscoverer, SnmpV1Config, SnmpV2cConfig, SnmpV3Config) from Products.ZenUtils.Utils import unused unused(Globals, DiscoverService, ModelerService, JobPropertiesProxy) DEFAULT_COMMUNITIES = ['public', 'private'] def _partitionPingResults(results): """Groups the results into a 'good' results and 'bad' results and returns each set as a tuple. @returns {tuple} (<good-results>, <bad-results>) """ good, bad = [], [] for result in results: if result.isUp: good.append(result.address) else:
from Products.ZenUtils.Exceptions import ZentinelException from Products.ZenUtils.Utils import unused from Products.ZenUtils.Driver import drive from Products.ZenUtils.IpUtil import asyncNameLookup, isip, parse_iprange, \ getHostByName, ipunwrap from Products.ZenUtils.NJobs import NJobs from Products.ZenUtils.snmp import SnmpV1Config, SnmpV2cConfig from Products.ZenUtils.snmp import SnmpAgentDiscoverer from Products.ZenModel.Exceptions import NoIPAddress from Products.ZenEvents.ZenEventClasses import Status_Snmp from Products.ZenEvents.Event import Info from Products.ZenStatus.PingService import PingService from Products.ZenHub.PBDaemon import FakeRemote, PBDaemon from Products.ZenHub.services import DiscoverService, ModelerService from Products.ZenHub.services.DiscoverService import JobPropertiesProxy unused(DiscoverService, ModelerService, JobPropertiesProxy) # for pb from twisted.internet.defer import succeed from twisted.python.failure import Failure from twisted.internet import reactor from twisted.names.error import DNSNameError class ZenDisc(ZenModeler): """ Scan networks and routes looking for devices to add to the ZODB """ initialServices = PBDaemon.initialServices + ['DiscoverService'] name = 'zendisc' scanned = 0