history.py

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

    def fill(self):
        self.rows = []
        formatData = {}

        if self.events:
           for event in self.events:
                # Default description formatting (used if no format
                # string is returned by getFormatting()
                default = ['Event: ' + G_EVENTTYPE + ', '
                           'Alert: ' + G_ALERTTYPE + ' '
                           #'Vars: ' + G_ALLVARS +
                           '\n' + G_ALLMSGS]

                formatString = self.getFormatting(event)
                if not formatString:
                    formatString = default

                startTime = event.start_time.strftime(TIMEFORMAT)
                endTime = None
                if event.end_time:
                    if event.end_time == INFINITY:
                        endTime = 'Still active'
                    else:
                        endTime = event.end_time.strftime(TIMEFORMAT)

                descr = self.format(formatString,event)

                self.rows.append([[startTime],[endTime],descr])

    def format(self,formatList,event):
        formattedList = []
        for formatString in formatList:
            regexp = re.compile("\$(\w+)\$")

            while regexp.search(formatString):
                match = regexp.search(formatString).groups()[0]

                match = '$' + match + '$'
                var = self.tokenVars[match][0]
                state = self.tokenVars[match][1]
                data = event.getVar(var,state)

                formatString = formatString.replace(match,data)

            # Globals
            regexp = re.compile("\%(\w+)\%")
            while regexp.search(formatString):
                match = regexp.search(formatString).groups()[0]

                match = '%' + match + '%'
                data = getattr(event,self.globalVars[match])

                formatString = formatString.replace(match,str(data))
            formattedList.append(formatString)
        return formattedList

class LocationHistoryBox(HistoryBox):
    def __init__(self, locationid, startTime, endTime, eventtypes, alerttypes):
        loc = nav.db.manage.Location(locationid)
        self.title = loc.descr

        ec = EventCollector(orderBy='start_time desc',
                            startTime=startTime, endTime=endTime,
                            eventtypes=eventtypes, alerttypes=alerttypes)
        vars = [['locationid',locationid]]
        self.events = ec.getEventsByVar(vars)
        self.fill()

    def getFormatting(self,event):
        formatString = None
        if event.eventtypeid == 'deviceActive':
            # deviceAcrive events doesn't have locationid, so
            # there is no need to provide formatting
            pass
        elif event.eventtypeid == 'deviceState':
            pass
        elif event.eventtypeid == 'deviceNotice':
            if event.alerttype == 'deviceError':
                unitType = event.getVar('unittype',
                                        DeviceEvent.STATE_NONE)
        return formatString

class RoomHistoryBox(HistoryBox):
    def __init__(self, roomid, startTime, endTime, eventtypes, alerttypes):
        room = nav.db.manage.Room(roomid)
        self.title = str(roomid) + ' (' + room.descr + ')'

        ec = EventCollector(orderBy='start_time desc',
                            startTime=startTime, endTime=endTime,
                            eventtypes=eventtypes, alerttypes=alerttypes)
        vars = [['roomid',roomid]]
        self.events = ec.getEventsByVar(vars)
        self.fill()

    def getFormatting(self,event):
        formatString = None
        if event.eventtypeid == 'deviceActive':
            # deviceAcrive events doesn't have locationid, so
            # there is no need to provide formatting
            pass
        elif event.eventtypeid == 'deviceState':
            pass
        elif event.eventtypeid == 'deviceNotice':
            if event.alerttype == 'deviceError':
                unitType = event.getVar('unittype',
                                        DeviceEvent.STATE_NONE)
        return formatString

class NetboxHistoryBox(HistoryBox):
    def __init__(self, netboxid, startTime, endTime, eventtypes, alerttypes):
        box = nav.db.manage.Netbox(netboxid)
        self.title = box.sysname

        ec = EventCollector(orderBy='start_time desc',
                            startTime=startTime, endTime=endTime,
                            eventtypes=eventtypes, alerttypes=alerttypes)
        try:
            deviceid = nav.db.manage.Netbox(netboxid).device.deviceid
        except forgetSQL.NotFound:
            deviceid = None
        if deviceid:
            self.events = ec.getEventsByDeviceid([deviceid])
        else:
            self.events = None
        self.fill()

    def getFormatting(self,event):
        formatString = None
        if event.eventtypeid == 'deviceActive':
            # deviceAcrive events doesn't have locationid, so
            # there is no need to provide formatting
            pass
        elif event.eventtypeid == 'deviceState':
            pass
        elif event.eventtypeid == 'deviceNotice':
            if event.alerttype == 'deviceError':
                unitType = event.getVar('unittype',
                                        DeviceEvent.STATE_NONE)
        return formatString


class ModuleHistoryBox(HistoryBox):
    def __init__(self, moduleid, startTime, endTime, eventtypes, alerttypes):
        module = nav.db.manage.Module(moduleid)

        self.title = 'Module ' + str(module.module) + ' in ' + \
                      module.netbox.sysname

        ec = EventCollector(orderBy='start_time desc',
                            startTime=startTime, endTime=endTime,
                            eventtypes=eventtypes, alerttypes=alerttypes)
        try:
            deviceid = nav.db.manage.Module(moduleid).device.deviceid
        except forgetSQL.NotFound:
            deviceid = None
        if deviceid:
            self.events = ec.getEventsByDeviceid([deviceid])
        else:
            self.events = None
        self.fill()

    def getFormatting(self,event):
        formatString = None
        if event.eventtypeid == 'deviceActive':
            # deviceAcrive events doesn't have locationid, so
            # there is no need to provide formatting
            pass
        elif event.eventtypeid == 'deviceState':
            pass
        elif event.eventtypeid == 'deviceNotice':
            if event.alerttype == 'deviceError':
                unitType = event.getVar('unittype',
                                        DeviceEvent.STATE_NONE)

        return formatString

class DeviceHistoryBox(HistoryBox):
    def __init__(self, deviceid, startTime, endTime, eventtypes, alerttypes):
        device = nav.db.manage.Device(deviceid)
        self.title = 'Device not currently in operation (%s)' % (device.serial,)

        ec = EventCollector(orderBy='start_time desc',
                            startTime=startTime, endTime=endTime,
                            eventtypes=eventtypes, alerttypes=alerttypes)
        self.events = ec.getEventsByDeviceid([deviceid])
        self.fill()

    def getFormatting(self,event):
        formatString = None
        if event.eventtypeid == 'deviceActive':
            # deviceAcrive events doesn't have locationid, so
            # there is no need to provide formatting
            pass
        elif event.eventtypeid == 'deviceState':
            pass
        elif event.eventtypeid == 'deviceNotice':
            if event.alerttype == 'deviceError':
                unitType = event.getVar('unittype',
                                        DeviceEvent.STATE_NONE)
        return formatString

class History:
    """
    The interpreted history for a device (netbox or module)
    """

    url = None
    sysname = None

    def __init__(self,deviceId,netboxId=None,moduleId=None):
        self.deviceId = deviceId
        self.netboxId = netboxId
        self.moduleId = moduleId
        self.events = []
        self.moduleevents = []
        self.error = None
        self.getHistory()

        if self.netboxId:
            self.url = urlbuilder.createUrl(id=netboxId,division='netbox')
            self.sysname = dtTables.Netbox(netboxId).sysname
        if self.moduleId:
            module = dtTables.Module(moduleId)
            self.module = module.module
            self.sysname = module.netbox.sysname
            self.url = urlbuilder.createUrl(id=module.netbox.netboxid,
            division='netbox')

    def addEvent(self,sort_key, e, modulehist=False):
        if not modulehist:
            self.events.append((sort_key,e))
        else:
            self.moduleevents.append((sort_key,e))

    def getHistory(self):
        # This should be replaced by urlbuilder stuff:
        HISTORYPATH = BASEPATH + 'history/device/'
        if self.deviceId:
            # Display the history for a device

            where = ["deviceid=%s" % (self.deviceId,),"""eventtypeid='deviceOrdered' or eventtypeid='deviceRegistered' or eventtypeid='deviceInOperation' or eventtypeid='deviceError' or eventtypeid='deviceSwUpgrade' or eventtypeid='deviceHwUpgrade' or eventtypeid='deviceRma'"""]
            events = dtTables.AlerthistDt.getAll(where)

            try:
                # Try to load this device from the db, if it doesnt exist this will
                # fail and raise a forgetSQL.NotFound exception
                device = dtTables.DeviceDt(self.deviceId)
                device.load()
                self.netbox = device.getNetbox()

                for de in events:
                    # de.state can only be trusted on events that send
                    # vars with start and end events. fix this by looking
                    # for end_time equal or not equal to INFINITY

                    eventtype = de.eventtype.eventtypeid

                    if eventtype == 'deviceOrdered' and de.end_time == INFINITY:
                        # A deviceOrdered start event
                        e = {'eventType': 'Ordered',
                             'time': de.start_time.strftime(DATEFORMAT),
                             'descr': 'Ordered by %s for %s from %s' %
                             (de.vars['username'],de.vars['orgid'],
                             de.vars['retailer'])}
                        sort_key = de.start_time
                        self.addEvent(sort_key,e)
                    elif eventtype == 'deviceOrdered' and de.end_time != INFINITY:
                        # A deviceOrdered end event
                        # start
                        e = {'eventType': 'Ordered',
                             'time': de.start_time.strftime(DATEFORMAT),
                             'descr': 'Ordered by %s for %s from %s' %
                             (de.getVar('username','s'),de.getVar('orgid','s'),
                             de.getVar('retailer','s'))}
                        sort_key = de.start_time
                        self.addEvent(sort_key,e)
                        # end
                        e = {'eventType': 'Arrived',
                             'time': de.end_time.strftime(DATEFORMAT),
                             'descr': 'Registered with serialnumber "%s" by %s'\
                             % (de.device.serial,de.getVar('username','e'))}
                        sort_key = de.end_time
                        self.addEvent(sort_key,e)
                    elif eventtype == 'deviceRegistered':
                        # A deviceRegistered event
                        e = {'eventType': 'Registered',
                             'time': de.start_time.strftime(DATEFORMAT),
                             'descr': 'Registered with serialnumber "%s" by %s'\
                             % (de.device.serial,de.getVar('username'))}
                        sort_key = de.start_time
                        self.addEvent(sort_key,e)
                    elif eventtype == 'deviceError':
                        # A deviceError event
                        e = {'eventType': 'Error',
                             'time': de.start_time.strftime(TIMEFORMAT),
                             'descr': de.getVar('comment')}
                        sort_key = de.start_time
                        self.addEvent(sort_key,e)
                    elif eventtype == 'deviceInOperation' and \
                    de.end_time == INFINITY:
                        # A deviceInOperation event (still in operation)
                        if de.netbox:
                            sysname = de.getVar('sysname','s')
                            descr = 'Device in operation as netbox %s' % sysname
                        if de.subid:
                            module = de.getVar('module','s')
                            descr = 'Device in operation as module %s in \
                            netbox %s' % (module,sysname)
                        e = {'eventType': 'In operation',
                             'time': de.start_time.strftime(TIMEFORMAT),
                             'descr': descr}
                        sort_key = de.start_time
                        self.addEvent(sort_key,e)
                    elif eventtype == 'deviceInOperation' and \
                    de.end_time != INFINITY:
                        # A deviceInOperation event (finished)
                        # the start event
                        if de.netbox:
                            sysname = de.getVar('sysname','s')
                            descr = 'Device in operation as netbox %s' % sysname