def datagramReceived(self, msg, client_address): """ Consume the network packet @param msg: syslog message @type msg: string @param client_address: IP info of the remote device (ipaddr, port) @type client_address: tuple of (string, number) """ if msg == "": self.log.debug("Received empty datagram. Discarding.") return (ipaddr, port) = client_address if self.options.logorig: if self.options.logformat == 'human': message = self.expand(msg, client_address) else: message = msg self.olog.info(message) if self.options.noreverseLookup: d = defer.succeed(ipaddr) else: d = asyncNameLookup(ipaddr) d.addBoth(self.gotHostname, (msg, ipaddr, time.time()))
def inner(driver): """ Twisted driver class to iterate through devices @param driver: Zenoss driver @type driver: Zenoss driver @return: successful result is a list of IPs that were added @rtype: Twisted deferred @todo: modularize this function (130+ lines is ridiculous) """ try: kw = dict(deviceName=ip, discoverProto=None, devicePath=devicepath, performanceMonitor=self.options.monitor, productionState=prodState) # If zProperties are set via a job, get them and pass them in if self.options.job: yield self.config().callRemote('getJobProperties', self.options.job) job_props = driver.next() if job_props is not None: # grab zProperties from Job kw['zProperties'] = getattr(job_props, 'zProperties', {}) # grab other Device properties from jobs #deviceProps = job_props.get('deviceProps', {}) #kw.update(deviceProps) #@FIXME we are not getting deviceProps, check calling # chain for clues. twisted upgrade heartburn perhaps? # if we are using SNMP, lookup the device SNMP info and use the # name defined there for deviceName if not self.options.nosnmp: self.log.debug("Scanning device with address %s", ip) snmpCommunities = kw.get('zProperties', {}).get( 'zSnmpCommunities', None) yield self.findRemoteDeviceInfo(ip, devicepath, snmpCommunities) snmp_config = driver.next() if snmp_config: if snmp_config.sysName: kw['deviceName'] = snmp_config.sysName if snmp_config.version: kw['zSnmpVer'] = snmp_config.version if snmp_config.port: kw['zSnmpPort'] = snmp_config.port if snmp_config.community: kw['zSnmpCommunity'] = snmp_config.community # if we are using SNMP, did not find any snmp info, # and we are in strict discovery mode, do not # create a device elif self.options.zSnmpStrictDiscovery: self.log.info('zSnmpStrictDiscovery is True. ' + 'Not creating device for %s.' % ip ) return # RULES FOR DEVICE NAMING: # 1. If zPreferSnmpNaming is true: # If snmp name is returned, use snmp name. Otherwise, # use the passed device name. If no device name was passed, # do a dns lookup on the ip. # 2. If zPreferSnmpNaming is false: # If we are discovering a single device and a name is # passed in instead of an IP, use the passed-in name. # Otherwise, do a dns lookup on the ip. if self.options.zPreferSnmpNaming and \ not isip( kw['deviceName'] ): # In this case, we want to keep kw['deviceName'] as-is, # because it is what we got from snmp pass elif self.options.device and not isip(self.options.device): kw['deviceName'] = self.options.device else: # An IP was passed in so we do a reverse lookup on it to get # deviceName yield asyncNameLookup(ip) try: kw.update(dict(deviceName=driver.next())) except Exception, ex: self.log.debug("Failed to lookup %s (%s)" % (ip, ex)) # If it's discovering a particular device, # ignore zAutoDiscover limitations forceDiscovery = bool(self.options.device) # now create the device by calling zenhub yield self.config().callRemote('createDevice', ipunwrap(ip), force=forceDiscovery, **kw) result = driver.next() self.log.debug("ZenDisc.discoverDevice.inner: got result from remote_createDevice") if isinstance(result, Failure): raise ZentinelException(result.value) dev, created = result # if no device came back from createDevice we assume that it # was told to not auto-discover the device. This seems very # dubious to me! -EAD if not dev: self.log.info("IP '%s' on no auto-discover, skipping",ip) return else: # A device came back and it already existed. if not created and not dev.temp_device: # if we shouldn't remodel skip the device by returning # at the end of this block if not self.options.remodel: self.log.info("Found IP '%s' on device '%s';" " skipping discovery", ip, dev.id) if self.options.device: self.setExitCode(3) yield succeed(dev) driver.next() return else: # we continue on to model the device. self.log.info("IP '%s' on device '%s' remodel", ip, dev.id) self.sendDiscoveredEvent(ip, dev) # the device that we found/created or that should be remodeled # is added to the list of devices to be modeled later if not self.options.nosnmp: self.discovered.append(dev.id) yield succeed(dev) driver.next()
def discoverDevice(self, ip, devicepath=None, prodState=None): """ Discover the device at the given IP address. @param ip: IP address @type ip: string @param devicepath: where in the DMD to put any discovered devices @type devicepath: string @param prodState: production state (see Admin Guide for a description) @type prodState: integer @return: Twisted/Zenoss Python iterable @rtype: Python iterable """ if devicepath is None: devicepath = self.options.deviceclass if prodState is None: prodState = self.options.productionState self.scanned += 1 if self.options.maxdevices: if self.scanned >= self.options.maxdevices: self.log.info("Limit of %d devices reached", self.options.maxdevices) defer.returnValue(None) try: kw = dict(deviceName=ip, discoverProto=None, devicePath=devicepath, performanceMonitor=self.options.monitor, productionState=prodState) # If zProperties are set via a job, get them and pass them in if self.options.job: job_props = yield self.config().callRemote( 'getJobProperties', self.options.job) if job_props is not None: # grab zProperties from Job kw['zProperties'] = getattr(job_props, 'zProperties', {}) # grab other Device properties from jobs # deviceProps = job_props.get('deviceProps', {}) # kw.update(deviceProps) # @FIXME we are not getting deviceProps, check calling # chain for clues. twisted upgrade heartburn perhaps? # if we are using SNMP, lookup the device SNMP info and use the # name defined there for deviceName if not self.options.nosnmp: self.log.debug("Scanning device with address %s", ip) snmpCommunities = \ kw.get('zProperties', {}).get('zSnmpCommunities', None) snmp_config = yield self.findRemoteDeviceInfo( ip, devicepath, snmpCommunities) if snmp_config: if snmp_config.sysName: kw['deviceName'] = snmp_config.sysName if snmp_config.version: kw['zSnmpVer'] = snmp_config.version if snmp_config.port: kw['zSnmpPort'] = snmp_config.port if snmp_config.community: kw['zSnmpCommunity'] = snmp_config.community # Since we did not find any snmp info and we are in # strict discovery mode, do not create a device elif self.options.zSnmpStrictDiscovery: self.log.info( "zSnmpStrictDiscovery is True. " "Not creating device for %s.", ip) defer.returnValue(None) # RULES FOR DEVICE NAMING: # 1. If zPreferSnmpNaming is true: # If snmp name is returned, use snmp name. Otherwise, # use the passed device name. If no device name was passed, # do a dns lookup on the ip. # 2. If zPreferSnmpNaming is false: # If we are discovering a single device and a name is # passed in instead of an IP, use the passed-in name. # Otherwise, do a dns lookup on the ip. if self.options.zPreferSnmpNaming and not isip(kw['deviceName']): # In this case, we want to keep kw['deviceName'] as-is, # because it is what we got from snmp pass elif self.options.device and not isip(self.options.device): kw['deviceName'] = self.options.device else: # An IP was passed in so we do a reverse lookup on it to get # deviceName try: kw["deviceName"] = yield asyncNameLookup(ip) except Exception as ex: self.log.debug("Failed to lookup %s (%s)", ip, ex) # If it's discovering a particular device, # ignore zAutoDiscover limitations forceDiscovery = bool(self.options.device) # now create the device by calling zenhub result = None try: result = yield self.config().callRemote('createDevice', ipunwrap(ip), force=forceDiscovery, **kw) except Exception as ex: raise ZentinelException(ex) self.log.debug("Got result from remote_createDevice: %s", result) dev, created = result # if no device came back from createDevice we assume that it # was told to not auto-discover the device. This seems very # dubious to me! -EAD if not dev: self.log.info("IP '%s' on no auto-discover, skipping", ip) defer.returnValue(None) # A device came back and it already existed. if not created and not dev.temp_device: # if we shouldn't remodel skip the device by returning # at the end of this block if not self.options.remodel: self.log.info( "Found IP '%s' on device '%s';" " skipping discovery", ip, dev.id) if self.options.device: self.setExitCode(3) defer.returnValue(dev) else: # we continue on to model the device. self.log.info("IP '%s' on device '%s' remodel", ip, dev.id) self.sendDiscoveredEvent(ip, dev) # the device that we found/created or that should be remodeled # is added to the list of devices to be modeled later if not self.options.nosnmp: self.discovered.append(dev.id) yield self.config().callRemote('succeedDiscovery', dev.id) defer.returnValue(dev) except ZentinelException as e: self.log.exception(e) if self.options.snmpMissing: self.sendEvent( dict(device=ip, component=ip, ipAddress=ip, eventKey=ip, eventClass=Status_Snmp, summary=str(e), severity=Info, agent="Discover")) except Exception as e: self.log.exception("Failed device discovery for '%s'", ip) finally: self.log.info("Finished scanning device with address %s", ip)
def inner(driver): """ Twisted driver class to iterate through devices @param driver: Zenoss driver @type driver: Zenoss driver @return: successful result is a list of IPs that were added @rtype: Twisted deferred @todo: modularize this function (130+ lines is ridiculous) """ try: kw = dict(deviceName=ip, discoverProto=None, devicePath=devicepath, performanceMonitor=self.options.monitor, productionState=prodState) # If zProperties are set via a job, get them and pass them in if self.options.job: yield self.config().callRemote('getJobProperties', self.options.job) job_props = driver.next() if job_props is not None: # grab zProperties from Job kw['zProperties'] = getattr(job_props, 'zProperties', {}) # grab other Device properties from jobs #deviceProps = job_props.get('deviceProps', {}) #kw.update(deviceProps) #@FIXME we are not getting deviceProps, check calling # chain for clues. twisted upgrade heartburn perhaps? # if we are using SNMP, lookup the device SNMP info and use the # name defined there for deviceName if not self.options.nosnmp: self.log.debug("Scanning device with address %s", ip) snmpCommunities = kw.get('zProperties', {}).get('zSnmpCommunities', None) yield self.findRemoteDeviceInfo(ip, devicepath, snmpCommunities) snmp_config = driver.next() if snmp_config: if snmp_config.sysName: kw['deviceName'] = snmp_config.sysName if snmp_config.version: kw['zSnmpVer'] = snmp_config.version if snmp_config.port: kw['zSnmpPort'] = snmp_config.port if snmp_config.community: kw['zSnmpCommunity'] = snmp_config.community # if we are using SNMP, did not find any snmp info, # and we are in strict discovery mode, do not # create a device elif self.options.zSnmpStrictDiscovery: self.log.info('zSnmpStrictDiscovery is True. ' + 'Not creating device for %s.' % ip) return # RULES FOR DEVICE NAMING: # 1. If zPreferSnmpNaming is true: # If snmp name is returned, use snmp name. Otherwise, # use the passed device name. If no device name was passed, # do a dns lookup on the ip. # 2. If zPreferSnmpNaming is false: # If we are discovering a single device and a name is # passed in instead of an IP, use the passed-in name. # Otherwise, do a dns lookup on the ip. if self.options.zPreferSnmpNaming and \ not isip( kw['deviceName'] ): # In this case, we want to keep kw['deviceName'] as-is, # because it is what we got from snmp pass elif self.options.device and not isip(self.options.device): kw['deviceName'] = self.options.device else: # An IP was passed in so we do a reverse lookup on it to get # deviceName yield asyncNameLookup(ip) try: kw.update(dict(deviceName=driver.next())) except Exception, ex: self.log.debug("Failed to lookup %s (%s)" % (ip, ex)) # If it's discovering a particular device, # ignore zAutoDiscover limitations forceDiscovery = bool(self.options.device) # now create the device by calling zenhub yield self.config().callRemote('createDevice', ipunwrap(ip), force=forceDiscovery, **kw) result = driver.next() self.log.debug( "ZenDisc.discoverDevice.inner: got result from remote_createDevice" ) if isinstance(result, Failure): raise ZentinelException(result.value) dev, created = result # if no device came back from createDevice we assume that it # was told to not auto-discover the device. This seems very # dubious to me! -EAD if not dev: self.log.info("IP '%s' on no auto-discover, skipping", ip) return else: # A device came back and it already existed. if not created and not dev.temp_device: # if we shouldn't remodel skip the device by returning # at the end of this block if not self.options.remodel: self.log.info( "Found IP '%s' on device '%s';" " skipping discovery", ip, dev.id) if self.options.device: self.setExitCode(3) yield succeed(dev) driver.next() return else: # we continue on to model the device. self.log.info("IP '%s' on device '%s' remodel", ip, dev.id) self.sendDiscoveredEvent(ip, dev) # the device that we found/created or that should be remodeled # is added to the list of devices to be modeled later if not self.options.nosnmp: self.discovered.append(dev.id) yield succeed(dev) driver.next()
def discoverDevice(self, ip, devicepath=None, prodState=None, deviceConfig=None): """ Discover the device at the given IP address. @param ip: IP address @type ip: string @param devicepath: where in the DMD to put any discovered devices @type devicepath: string @param prodState: production state (see Admin Guide for a description) @type prodState: integer @return: Twisted/Zenoss Python iterable @rtype: Python iterable """ if devicepath is None: devicepath = self.options.deviceclass if prodState is None: prodState = self.options.productionState self.scanned += 1 if self.options.maxdevices: if self.scanned >= self.options.maxdevices: self.log.info("Limit of %d devices reached", self.options.maxdevices) defer.returnValue(None) try: kw = dict( deviceName=ip, discoverProto=None, devicePath=devicepath, performanceMonitor=self.options.monitor, locationPath=self.options.location, groupPaths=self.options.groups, systemPaths=self.options.systems, productionState=prodState ) # If zProperties are set via a job, get them and pass them in if self.options.job: job_props = yield self.config().callRemote( 'getJobProperties', self.options.job ) if job_props is not None: # grab zProperties from Job kw['zProperties'] = getattr(job_props, 'zProperties', {}) # grab other Device properties from jobs # deviceProps = job_props.get('deviceProps', {}) # kw.update(deviceProps) # @FIXME we are not getting deviceProps, check calling # chain for clues. twisted upgrade heartburn perhaps? # if we are using SNMP, lookup the device SNMP info and use the # name defined there for deviceName if not self.options.nosnmp: self.log.debug("Scanning device with address %s", ip) zProps = kw.get('zProperties', {}) deviceSnmpCommunities = zProps.get('zSnmpCommunities', None) if not deviceSnmpCommunities and deviceConfig: deviceSnmpCommunities = getattr( deviceConfig, 'zSnmpCommunities', None) snmp_config = yield self.findRemoteDeviceInfo( ip, devicepath, deviceSnmpCommunities ) if snmp_config: if snmp_config.sysName: kw['deviceName'] = snmp_config.sysName if snmp_config.version: kw['zSnmpVer'] = snmp_config.version if snmp_config.port: kw['zSnmpPort'] = snmp_config.port if snmp_config.community: kw['zSnmpCommunity'] = snmp_config.community # Since we did not find any snmp info and we are in # strict discovery mode, do not create a device elif self.options.zSnmpStrictDiscovery: self.log.info( "zSnmpStrictDiscovery is True. " "Not creating device for %s.", ip ) defer.returnValue(None) # RULES FOR DEVICE NAMING: # 1. If zPreferSnmpNaming is true: # If snmp name is returned, use snmp name. Otherwise, # use the passed device name. If no device name was passed, # do a dns lookup on the ip. # 2. If zPreferSnmpNaming is false: # If we are discovering a single device and a name is # passed in instead of an IP, use the passed-in name. # Otherwise, do a dns lookup on the ip. if self.options.zPreferSnmpNaming and not isip(kw['deviceName']): # In this case, we want to keep kw['deviceName'] as-is, # because it is what we got from snmp pass elif self.options.device and not isip(self.options.device): kw['deviceName'] = self.options.device else: # An IP was passed in so we do a reverse lookup on it to get # deviceName try: kw["deviceName"] = yield asyncNameLookup(ip) except Exception as ex: self.log.debug("Failed to lookup %s (%s)", ip, ex) # If it's discovering a particular device, # ignore zAutoDiscover limitations forceDiscovery = bool(self.options.device) # now create the device by calling zenhub result = None try: result = yield self.config().callRemote( 'createDevice', ipunwrap(ip), force=forceDiscovery, **kw ) except Exception as ex: raise ZentinelException(ex) self.log.debug("Got result from remote_createDevice: %s", result) dev, created = result # if no device came back from createDevice we assume that it # was told to not auto-discover the device. This seems very # dubious to me! -EAD if not dev: self.log.info("IP '%s' on no auto-discover, skipping", ip) defer.returnValue(None) # A device came back and it already existed. if not created and not dev.temp_device: # if we shouldn't remodel skip the device by returning # at the end of this block if not self.options.remodel: self.log.info("Found IP '%s' on device '%s';" " skipping discovery", ip, dev.id) if self.options.device: self.setExitCode(3) defer.returnValue(dev) else: # we continue on to model the device. self.log.info("IP '%s' on device '%s' remodel", ip, dev.id) self.sendDiscoveredEvent(ip, dev) # the device that we found/created or that should be remodeled # is added to the list of devices to be modeled later if not self.options.nosnmp: self.discovered.append(dev.id) yield self.config().callRemote('succeedDiscovery', dev.id) defer.returnValue(dev) except ZentinelException as e: self.log.exception(e) if self.options.snmpMissing: self.sendEvent(dict( device=ip, component=ip, ipAddress=ip, eventKey=ip, eventClass=Status_Snmp, summary=str(e), severity=Info, agent="Discover" )) except Exception as e: self.log.exception("Failed device discovery for '%s'", ip) finally: self.log.info("Finished scanning device with address %s", ip)