netbox.py

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

        div['class'] = "alerts"
        div.append(html.Header("Recent alerts (last week)", level=3))
        div.append(table)
        if moreAlerts:
            div.append(html.Emphasis(html.Small("More alerts exists for this time frame.")))
        div.append(html.Division('See <a href="/devicemanagement/?box=%d&history=1">Device History</a> for more details.' % self.netboxid.netboxid))
        return div

    def showServices(self, sort):
        try:
            table = ServiceTable(netboxes=(self,), sort=sort)
        except NoServicesFound:
            return None
        div = html.Division()
        div.append(html.Header("Service availability", level=3))
        div.append(table.html)
        return div

    def showLinks(self):
        # Vi m氓 hente ifra swport-tabellen istedet!
        up = self.getChildrenIterator(manage.Swport, 'to_netbox')
        down = []
        for module in self.getChildrenIterator(manage.Module):
            modLinks = module.getChildrenIterator(manage.Swport, 'module')
            down.extend(modLinks)
        if not (up or down):
            return None
        info = html.Division()
        info.append(html.Header("Links with this box", level=2))
        def swporturl(netbox, module, port):
            """Generates a link to a given port"""
            url = urlbuilder.createUrl(netbox)
            url += 'module%s/port%s/' % (module, port)
            return html.Anchor(str(port), href=url)
        if up:
            for link in up:
                line = html.Division()
                info.append(line)
                line.append(urlbuilder.createLink(link.to_netbox))
                # His port
                line.append("(")
                if link.module and link.port:
                    line.append("%s %s" %
                            (link.module,
                             swporturl(link.netbox, link.module,link.port)))
                line.append("&nbsp;--&gt;&nbsp;")
                # our
                if link.to_module and link.to_port:
                    line.append("%s %s" %
                        (link.to_module,
                         swporturl(link.to_netbox, link.to_module,link.to_port)))
                line.append(")")
        if down:
            for link in down:
                line = html.Division()
                info.append(line)
                line.append(urlbuilder.createLink(link.to_netbox))
                # His port
                line.append("(")
                if link.to_module and link.to_port:
                    line.append("(%s %s" %
                        (link.to_module,
                         swporturl(link.to_netbox, link.to_module,link.to_port)))
                line.append("&nbsp;&lt;--&nbsp;")
                # our port
                if link.module and link.port:
                    line.append("%s %s" %
                            ( link.module,
                             swporturl(link.netbox, link.module,link.port)))
                line.append(")")
        return info

    def showRrds(self):
        rrdfiles = self.getChildrenIterator(manage.Rrd_file,
                   where="not subsystem in ('pping', 'serviceping')")
        if not rrdfiles:
            return None
        result = html.Division()
        result.append(html.Header("Statistics", level=3))
        rrdlist = html.UnorderedList()
        all = []
        for rrd in rrdfiles:
            info = "%s: %s" % (rrd.key, rrd.value)
            if rrd.key == 'swport' or rrd.key == 'gwport':
                continue # skip swports for now
                port = manage.Swport(rrd.value)
                try:
                    port.load()
                except:
                    port = None
                if port:
                    info = "%s %s %s" % (
                        port.module.netbox.sysname,
                        port.module.module,
                        port.port)

            for ds in rrd.getChildrenIterator(manage.Rrd_datasource):
                link = urlbuilder.createLink(subsystem='rrd',
                                             id=ds.rrd_datasourceid,
                                             division="datasources",
                                             content=(ds.descr or "(unknown)"))
                all.append(ds.rrd_datasourceid)
                rrdlist.append(html.ListItem(link))
        if not all:
            # skip if only ports where defined
            return None
        link = urlbuilder.createLink(subsystem='rrd',
                    id=all, division="datasources", content="[All]")
        rrdlist.append(html.ListItem(link))
        result.append(rrdlist)
        return result

    def showPorts(self, activePerspective='standard', interval=30):
        # ugly, but only those categorys have swports or gwports
        if self.cat.catid not in ('GW', 'GSW', 'SW', 'EDGE'):
            return None

        div = html.Division(_class="ports")
        div.append(html.Header('Port view', level=3))

        def perspectiveToggler(active):
            div = html.Division(_class="tabs")
            list = html.UnorderedList()
            div.append(list)

            perspectives = []
            if self.cat.catid in ('GSW', 'SW', 'EDGE'):
                perspectives.append(
                    ('Switch port status', 'portstatus', 'standard'))
                perspectives.append(
                    ('Switch port activity', 'activeports', 'active'))
            if self.cat.catid in ('GW', 'GSW'):
                perspectives.append(
                    ('Router port status', 'gwportstatus', 'gwstandard'))

            for p in perspectives:
                if active == p[2]:
                    list.append(html.ListItem(
                        html.Anchor(p[0]), _class='tabactive'))
                else:
                    list.append(html.ListItem(
                        html.Anchor(p[0], href='#',
                                    onClick="showPorts('%s'); return false" %
                                    p[1])))
            return div

        def intervalForm():
            form = html.Form(method="GET", action="")
            form.append(html.Hidden(name='perspective', value='active'))
            label = html.Label('Interval (in days):')
            label['for'] ='interval'
            form.append(label)
            form.append(html.Textfield(id='interval', name='interval',
                                       value=interval, size=3))
            form.append(html.Submit(value='Recheck activity'))
            return form

        def showPerspective(perspective, id):
            result = html.Division(id=id)
            result.append(perspectiveToggler(perspective))
            div = html.Division(_class='tabcontent')
            result.append(div)
            div.append(module.showModuleLegend(perspective=perspective,
                                               interval=interval))

            if perspective == 'active':
                div.append(intervalForm())
            modules = [m for m in self.getChildrenIterator(module.ModuleInfo)]
            if not modules:
                return None
            isNum = lambda x: x and re.match("^[0-9]+$",str(x))
            # h酶h酶
            modules.sort(lambda a,b:
                # sort by number - if possible
                (isNum(a.module) and isNum(b.module)
                 and cmp(int(a.module), int(b.module)))
                or cmp(a.module,b.module))
            for mod in modules:
                try:
                    moduleView = mod.showModule(perspective=perspective,
                                                interval=interval)
                    if moduleView:
                        div.append(moduleView)
                except AttributeError:
                    pass
            return result

        if self.cat.catid == 'GW':
            activePerspective = 'gwstandard'

        if self.cat.catid in ('GSW', 'SW', 'EDGE'):
            std = showPerspective('standard', 'portstatus')
            act = showPerspective('active', 'activeports')
        else:
            std = None
            act = None
        if self.cat.catid in ('GW', 'GSW'):
            gwstd = showPerspective('gwstandard', 'gwportstatus')
        else:
            gwstd = None

        if std:
            if not activePerspective == 'standard':
                std['style'] = 'display: none;'
            div.append(std)
        if act:
            if not activePerspective == 'active':
                act['style'] = 'display: none;'
            div.append(act)
        if gwstd:
            if not activePerspective == 'gwstandard':
                gwstd['style'] = 'display: none;'
            div.append(gwstd)
        return div

    def showLastUpdate(self):
        unixEpoch = DateTime.DateTime(1970)
        refreshUrl = urlbuilder.createUrl(division='netbox',
                                          id=self.netboxid.netboxid) + \
                                          '?refresh=1'
        refreshLink = html.Anchor('(Force refresh)', href=refreshUrl)

        infoBits = [i for i in
                    self.getChildrenIterator(manage.Netboxinfo,
                                             where="var='lastUpdated'")]
        if len(infoBits) > 0:
            try:
                lastUpdated = long(infoBits[0].val)
            except ValueError:
                return '(Invalid value in database)'

            # lastUpdated value is actually the number of milliseconds since
            # the epoch (apparently UTC time, not local), we use DateTime to
            # calculate a usable timestamp.
            lastUpdated = unixEpoch + \
                          DateTime.oneSecond * (lastUpdated / 1000.0)
            return "%s %s" % (str(lastUpdated.localtime()), refreshLink)
        else:
            return "N/A " + str(refreshLink)

    def showSoftware(self):
        return str(self.device.sw_ver or "N/A")

    def showSerialNumber(self):
        return str(self.device.serial or "N/A")

    def showModuleCount(self):
        count = len(manage.Module.getAllIDs(where='netboxid=%d'
                                            % self.netboxid.netboxid))
        return '<a href="/report/modules?sysname=%s">%d</a>' \
            % (self.sysname, count)

    def showSwportCount(self):
        count = 0
        modules = manage.Module.getAllIterator(where='netboxid=%d'
                                               % self.netboxid.netboxid)
        for module in modules:
            count += len(manage.Swport.getAllIDs(where='moduleid=%d'
                                                 % module.moduleid))
        return '<a href="/report/swport?b1.netboxid=%d">%d</a>' \
            % (self.netboxid.netboxid, count)

    def showGwportCount(self):
        count = 0
        modules = manage.Module.getAllIterator(where='netboxid=%d'
                                               % self.netboxid.netboxid)
        for module in modules:
            count += len(manage.Gwport.getAllIDs(where='moduleid=%d'
                                                 % module.moduleid))
        return '<a href="/report/gwport?netbox.netboxid=%d">%d</a>' \
            % (self.netboxid.netboxid, count)

    def showFirstDiscovered(self):
        return str(self.netboxid.discovered or 'N/A')

    def showActions(self):
        actions = html.Paragraph()
        actions.append('[%s]' % urlbuilder.createLink(self.netboxid,
                                                      subsystem='editdb',
                                                      content="Edit"))
        actions.append('[%s]' % urlbuilder.createLink(self.netboxid,
                                                      subsystem='maintenance',
                                                      content='Schedule maintenance'))
        actions.append('[<a href="/devicemanagement/?box=%d&history=1">Device history</a>]'
                       % self.netboxid.netboxid)
        return actions