Esempio n. 1
0
    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()))
Esempio n. 2
0
    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()))
Esempio n. 3
0
        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()
Esempio n. 4
0
    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)
Esempio n. 5
0
        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()
Esempio n. 6
0
    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)