netbox.py

监控大型网络的软件。能够自动发现拓扑结构

                age = (DateTime.now() - event.time).minutes
                logger.debug("Deleting stale refresh reply event "
                             "%s (%.01f minutes old)", event.eventqid, age)
                event.dispose()

        # Only check for replies if we actually know that we've posted an event
        if self.refreshVar in self.session:
            (refreshId, refreshTime) = self.session[self.refreshVar]
            events = EventQ.consumeEvents(target='devBrowse')
            logger.debug("Checking for refresh replies, found %d events "
                         "directed at me", len(events))
            deleteStale(events)
            # Get the event(s) directed at this refresh instance
            forMe = [event for event in events
                     if int(event.subid) == int(refreshId)]
            if len(forMe) > 0:
                logger.debug("Got reply event for refreshId=%s", refreshId)
                event = forMe[0]
                event.dispose()
                del self.session[self.refreshVar]
                self.session.save()
                return True
        return False

    def process(self):
        fields = self.request['fields']
        if 'refresh' in fields \
               and fields.getfirst('refresh').lower() == 'cancel':
            return self.cancelRefresh()
        return self._waitPage()

    def _waitPage(self):
        "Wait for gDD to reply to our refresh request"
        result = html.Division()
        timeElapsed = time.time() - self.session[self.refreshVar][1]
        waitString = '(%d seconds elapsed)' % timeElapsed
        result.append(html.Paragraph('Please wait for collector to ' + \
                                     'refresh data from %s %s...' %
                                     (self.netbox.sysname, waitString)))
        cancelForm = html.Form(method="GET", action="")
        cancelForm.append(html.Submit(name="refresh", value="Cancel"))
        result.append(cancelForm)
        self.request['templatePath'][-1] = \
                                         ('Refreshing ' + \
                                          self.request['templatePath'][-1][0],
                                          None)
        refreshMeta = '<meta http-equiv="refresh" content="5" />\n'
        self.request['template'].additionalMeta = lambda: refreshMeta
        return result


class NetboxInfo(manage.Netbox):
    def __init__(self, netbox):
        manage.Netbox.__init__(self, netbox)
        self.setPrefix()

    def showInfo(self):
        result = html.Division()
        title = html.Header(self.sysname, level=2)
        result.append(title)
        result.append(self.showActions())
        alerts = self.showAlerts()
        if alerts:
            result.append(alerts)
        info = html.SimpleTable()
        info['class'] = 'vertitable'
        info.add('Status', _statusTranslator.get(self.up, self.up))
        info.add('Availability', self.availability())
        info.add('Uptime', self.showUptime())
        info.add('IP address', self.showIp())
        info.add('Vlan', self.showVlan())
        info.add('Gateway', self.showGw())
        info.add('Uplink', self.showSw())
        info.add('Category', urlbuilder.createLink(self.cat,
            subsystem="report"))
        if self.type:
            info.add('Type', urlbuilder.createLink(self.type))
        info.add('Organisation', urlbuilder.createLink(self.org))
        info.add('Room', urlbuilder.createLink(self.room))
        info.add('Software', self.showSoftware())
        info.add('Serial number', self.showSerialNumber())
        info.add('# of modules', self.showModuleCount())
        info.add('# of switch ports', self.showSwportCount())
        info.add('# of router ports', self.showGwportCount())
        info.add('Last updated', self.showLastUpdate())
        info.add('First discovered', self.showFirstDiscovered())
        result.append(info)
        return result

    def setPrefix(self):
        prefixes = manage.Prefix.getAll(where="'%s' << netaddr" % self.ip,
                                        orderBy='netaddr')
        if not prefixes:
            self.prefix = 0
        else:
            # the last one is the one with most spesific network address
            self.prefix = prefixes[-1]

    def showGw(self):
        if not self.prefix:
            return 'Unknown'
        netmasklen = self.prefix.netaddr.split('/')[1]
        netmask = IPy.intToIp(IPy._prefixlenToNetmask(int(netmasklen), 4), 4)
        # Find the gw
        gws = self.prefix.getChildren(manage.Gwportprefix,
                                 orderBy=['hsrp','gwip'])
        if not gws:
            return 'Unknown'
        # If we have hsrp, the active gw is listed last
        # else, we select the one with lowest ip
        if gws[-1].hsrp:
            gw = gws[-1]
        else:
            gw = gws[0]
        gwNetbox = gw.gwport.module.netbox
        gwLink = urlbuilder.createLink(gwNetbox, content=gw.gwip)
        return "%s /%s (%s) " % (gwLink, netmasklen, netmask)

    def showVlan(self):
        if self.prefix:
            vlan = self.prefix.vlan
            vlan = urlbuilder.createLink(vlan,
                                         content="Vlan %s" % vlan.vlan)
        else:
            vlan = 'Unknown'
        return vlan

    def showSw(self):
        sw = self.getChildrenIterator(manage.Swport, 'to_netbox')
        if not sw:
            return 'Unknown'
        vlanList = []
        swList = []
        for i in sw:
            # vlan = i.vlan
            vlans = i.getChildrenIterator(manage.Swportvlan)
            for vlan in vlans:
                if i not in swList and vlan.direction=='n':
                    vlanList.append(vlan)
                    swList.append(i)
        #if len(vlans) > 1:
        #    return 'Unknown'
        #if len(swList) > 1:
            #raise str(swList)
        #    return 'Unknown'
        # raise str(swList)
        result = html.Division()
        #sw = swList[0]
        for sw in swList:
            swNetbox = sw.module.netbox
            swPort = sw.interface or sw.port
            swModule = sw.module.module
            swLink = urlbuilder.createLink(swNetbox)
            swLink.append('(Module %s, Interface %s)' % (swModule, swPort))
            div = html.Division()
            div.append(swLink)
            result.append(div)
        return result

    def showUptime(self):
        uptime = (DateTime.now() - self.upsince)
        formatted = ''
        if uptime.day == 1:
            formatted += '1 day '
        if uptime.day > 1:
            formatted += str(uptime.day) + ' days '
        if uptime.hour == 1:
            formatted += '1 hour '
        if uptime.hour > 1:
            formatted += str(uptime.hour) + ' hours '
        if uptime.minute == 1:
            formatted += '1 minute'
        if uptime.minute > 1:
            formatted += str(uptime.minute) + ' minutes'
        return formatted

    def showIp(self):
        return str(self.ip)

    def availability(self):
        TIMERANGES = ('day', 'week', 'month')
        rrdfiles = self.getChildren(manage.Rrd_file,
                                      where="subsystem='pping'")
        if not rrdfiles:
            return "Unknown"
        rrdfile = rrdfiles[0]
        datasources = [ds for ds in
                       rrdfile.getChildrenIterator(manage.Rrd_datasource)]
        if not datasources:
            return "Unknown"
        statusDS = None
        for ds in datasources:
            if ds.name == 'STATUS':
                statusDS = ds
        if not statusDS:
            return 'Unknown'
        result=html.Division()
        for timerange in TIMERANGES:
            value = self.rrdAverage(statusDS, timerange)
            if value is None:
                value = 0 # unknown -> not availabe..?
            else:
                value = (1-value)*100
            value = tableview.Value(value, "%")
            dsids = [ds.rrd_datasourceid for ds in datasources]
            link = urlbuilder.createLink(subsystem='rrd',
                                         division='datasources',
                                         id=dsids,
                                         tf=timerange,
                                         content=value)
            result.append(link)
        result.append(html.Small('(%s)' % ' / '.join(TIMERANGES)))
        return result

    def rrdAverage(self, ds, timeframe):
        rrd = presenter.presentation()
        rrd.timeLast(timeframe)
        rrd.addDs(ds)
        value = rrd.average()
        if not value:
            return None
        else:
            value = value[0]
        return value

    def showAlerts(self):
        alerts = self.getChildren(manage.Alerthist,
                                  orderBy='start_time',
                                  where= """end_time = 'infinity' OR
                                  (now() - end_time) < '1 week' """)
        alerts.reverse()
        # dirty dirty, we just requested ALL alerts from the database..
        if len(alerts) > 15:
            moreAlerts = True
        else:
            moreAlerts = False
        alerts = alerts[:15] # only the 15 last events
        if not alerts:
            return None
        table = html.SimpleTable("row")
        table.add("Event", "Start", "Downtime")
        for alert in alerts:
            row = []
            if alert.source == 'serviceping':
                service = manage.Service(alert.subid)
                try:
                    type = service.handler
                except:
                    type = "%s (%s)" % (alert.eventtype, alert.subid)
            else:
                type = str(alert.eventtype)

            msg = [m for m in
                   alert.getChildrenIterator(manage.Alerthistmsg,
                                             where="""msgtype='sms' """)]

            if msg:
                type = html.TableCell(type)
                type['title'] = msg[0].msg

            row.append(type)
            start_time = alert.start_time.strftime("%Y-%m-%d %H:%M")
            row.append(start_time)
            oneYear = DateTime.oneDay * 365
            if not alert.end_time:
                # should NOT be NULL, but sometimes it is ... brrr
                age = "Unknown"
            else:
                age = alert.end_time - alert.start_time
                end_time = alert.end_time.strftime("%Y-%m-%d %H:%M")
                if age > oneYear:
                    age = DateTime.now() - alert.start_time
                    end_time = 'Still down'
                if age > DateTime.oneDay:
                    age = "%dd %s" % (age.days, age.strftime("%kh %Mm"))
                else:
                    age = age.strftime("%kh %Mm")
                # note - %k is %H but without leading 0
            age = html.TableCell(age)
            age['title'] = end_time
            age['align'] = 'right'
            row.append(age)
            if end_time == 'Still down':
                table.add(_class="stillDown", *row)
            else:
                table.add(*row)
        div = html.Division()