history.py

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

                        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)
                        # the end event
                        if de.netbox:  
                            sysname = de.getVar('sysname','s')
                            descr = 'Device out of operation as netbox %s' % (sysname,)
                        if de.subid:
                            module = de.getVar('module','s')
                            descr = 'Device out of operation as module %s in \
                            netbox %s' % (module,sysname)
                        e = {'eventType': 'Out of operation',
                             'time': de.end_time.strftime(TIMEFORMAT),
                             'descr': descr}
                        sort_key = de.end_time
                        self.addEvent(sort_key,e)
                    elif eventtype == 'deviceSwUpgrade':
                        # A deviceSwUpgrade event
                        e = {'eventType': 'Software upgrade',
                             'time': de.start_time.strftime(TIMEFORMAT),
                             'descr': 'Upgraded from %s to %s' %
                             (de.getVar('oldversion'),de.getVar('newversion'))}
                        sort_key = de.start_time
                        self.addEvent(sort_key,e)
                    elif eventtype == 'deviceHwUpgrade':
                        # A devicHwUpgrade event
                        e = {'eventType': 'Hardware upgrade',
                             'time': de.start_time.strftime(TIMEFORMAT),
                             'descr': '%s' %
                             (de.getVar('description'),)}
                        sort_key = de.start_time
                        self.addEvent(sort_key,e)
                    elif eventtype == 'deviceRma' and de.end_time == INFINITY:
                        # A deviceRma start event
                        e = {'eventType': 'RMA registered',
                             'time': de.start_time.strftime(TIMEFORMAT),
                             'descr': 'Registered by %s with comment "%s"' %
                             (de.getVar('username','s'),de.getVar('comment','s'),)}
                        sort_key = de.start_time
                        self.addEvent(sort_key,e)
                    elif eventtype == 'deviceRma' and de.end_time != INFINITY:
                        # A deviceRma end event
                        e = {'eventType': 'RMA registered',
                             'time': de.start_time.strftime(TIMEFORMAT),
                             'descr': 'Registered by %s with comment "%s"' %
                             (de.getVar('username','s'),de.getVar('comment','s'),)}
                        sort_key = de.start_time
                        self.addEvent(sort_key,e)
                       # end of event
                        e = {'eventType': 'RMA returned',
                             'time': de.end_time.strftime(TIMEFORMAT),
                             'descr': 'Registered returned by %s' %
                             (de.getVar('username','e'),)}
                        sort_key = de.end_time
                        self.addEvent(sort_key,e)
                    else:
                        # Unknown event
                        if de.end_time == INFINITY:
                            end_time = 'infinity'
                        elif de.end_time:
                            end_time = de.end_time.strftime(TIMEFORMAT)
                        else:
                            end_time = ''
                        e = {'eventType': eventtype,
                             'time': de.start_time.strftime(TIMEFORMAT) \
                             + ' - ' + end_time,
                             'descr': 'Unknown event'}
                        sort_key = de.start_time
                        self.addEvent(sort_key,e)
                self.events.sort()

                # If this device is a netbox, make the module history for it
                if self.netbox:
                    where = ["netboxid=%s" % (self.netbox.netboxid,),"eventtypeid='deviceInOperation'"]
                    events = dtTables.AlerthistDt.getAll(where)

                    for de in events:
                        if de.subid:
                            # This is a deviceInOperation event for a module
                            if de.end_time == INFINITY:
                            # A deviceInOperation event (still in operation)
                                if de.subid:
                                    module = de.getVar('module','s')
                                    descr = 'Module <a href="%s%s">%s</a> added to \
                                    netbox %s' % (HISTORYPATH,de.device.deviceid,module,sysname)
                                    e = {'eventType': 'In operation',
                                        'time': de.start_time.strftime(TIMEFORMAT),
                                        'descr': descr}
                                    sort_key = de.start_time
                                    self.addEvent(sort_key,e,True)
                            if de.end_time != INFINITY:
                                # A deviceInOperation event (finished)
                                # the start event
                                if de.subid:
                                    module = de.getVar('module','s')
                                    descr = 'Module <a href="%s%s">%s</a> added to \
                                    netbox %s' % (HISTORYPATH,de.device.deviceid,module,sysname)
                                    e = {'eventType': 'In operation',
                                         'time': de.start_time.strftime(TIMEFORMAT),
                                         'descr': descr}
                                    sort_key = de.start_time
                                    self.addEvent(sort_key,e,True)
                                # the end event
                                if de.subid:
                                    module = de.getVar('module','s')
                                    descr = 'Module <a href="%s%s">%s</a> removed from \
                                    netbox %s' % (HISTORYPATH,de.device.deviceid,module,sysname)
                                    e = {'eventType': 'Out of operation',
                                         'time': de.end_time.strftime(TIMEFORMAT),
                                         'descr': descr}
                                    sort_key = de.end_time
                                    self.addEvent(sort_key,e,True)
                    self.moduleevents.sort()

                if not (self.events or self.moduleevents):
                    self.error = 'No history registered for this device'

            except forgetSQL.NotFound,e:
                self.error = 'No device with deviceid ' + str(self.deviceId)

class EventCollector:
    def __init__(self, eventtypes=None, alerttypes=None, limit=None,
                 offset=None, orderBy=None, startTime=None, endTime=None):

        self.eventtypes = eventtypes or []
        self.alerttypes = alerttypes or []
        self.limit = limit
        self.offset = offset
        self.orderBy = orderBy
        self.startTime = startTime
        self.endTime = endTime

    def getEventsByVar(self,vars):
        # vars: list of [var,value]

        # SQL for list of alerthistids
        sql = "SELECT DISTINCT alerthist.alerthistid FROM " +\
              "alerthist,alerthistvar WHERE " +\
              "alerthist.alerthistid=alerthistvar.alerthistid AND "

        first = True
        for var,val in vars:
            if not first:
                sql += "AND "
            sql += "(alerthistvar.var='%s' AND alerthistvar.val='%s') " % \
                   (var,val)
            first = False
        return self.getEvents(idsql=sql)

    def getEventsByDeviceid(self,deviceids):
        # deviceids: list of deviceids

        sql = "("

        first = True
        for id in deviceids:
            if not first:
                sql += "OR "
            sql += "alerthist.deviceid='%s' " % (id,)
            first = False
        sql += ") "
        return self.getEvents(where=sql)

    def getEvents(self,idsql=None,where=None):
        # idsql: sql that selects list of alerthist ids
        # where: where clause to add

        sql = """
SELECT
    alerthist.alerthistid,
    alerthist.source,
    alerthist.deviceid,
    alerthist.netboxid,
    alerthist.subid,
    alerthist.start_time,
    alerthist.end_time,
    alerthist.eventtypeid,
    alerthist.value,
    alerthist.severity,
    alerthist.alerttypeid,
    alerttype.alerttype
FROM
    alerthist LEFT JOIN alerttype USING (alerttypeid)
"""

        addedWhere = False

        # Limit on select of alerthistids
        if idsql:
            if not addedWhere:
                sql += "WHERE "
                addedWhere = True
            else:
                sql += "AND "
            sql += "alerthist.alerthistid IN (%s) " % (idsql,)

        # Add where
        if where:
            if not addedWhere:
                sql += "WHERE "
                addedWhere = True
            else:
                sql += "AND "
            sql += where + " "

        # Limit on eventtypes
        if self.eventtypes:
            if not addedWhere:
                sql += "WHERE "
                addedWhere = True
            else:
                sql += "AND "
            first = True
            sql += "("
            for eventtype in self.eventtypes:
                if not first:
                    sql += "OR "
                sql += "alerthist.eventtypeid='%s' " % (eventtype,)
                first = False
            sql += ") "

        # Limit on alerttypes
        if self.alerttypes:
            if not addedWhere:
                sql += "WHERE "
                addedWhere = True
            else:
                sql += "AND "
            first = True
            sql += "("
            for alerttype in self.alerttypes:
                if not first:
                    sql += "OR "
                # Get alerttypeid
                atidsql = "(SELECT alerttypeid FROM alerttype WHERE " +\
                          "alerttype='%s')" % (alerttype,)

                sql += "alerthist.alerttypeid=%s" % (atidsql,)
                first = False
            sql += ") "

        # Limit on time interval
        if self.startTime and self.endTime:
            if not addedWhere:
                sql += "WHERE "
                addedWhere = True
            else:
                sql += "AND "
            # Get all events with event start < interval end, and event end >
            # interval start. In the case of a stateless event (end = NULL),
            # also check that event start > interval start.
            sql += """(alerthist.start_time <= '%(end)s')
                      AND (alerthist.end_time >= '%(start)s'
                           OR (alerthist.end_time IS NULL
                               AND alerthist.start_time >= '%(start)s')) """ % \
                   {'start': self.startTime.strftime('%Y-%m-%d 00:00:00'),
                    'end': self.endTime.strftime('%Y-%m-%d 23:59:59')}

        # Add order by
        if self.orderBy:
            sql += "ORDER BY %s " % (self.orderBy,)

        # Add limit
        if self.limit:
            sql += "LIMIT %s " % (self.limit,)

        # Add offset
        if self.offset:
            sql += "OFFSET %s " % (self.limit,)

        connection = nav.db.getConnection('devicemanagement','manage')
        database = connection.cursor()
        database.execute(sql)
        result = database.dictfetchall()

        events = []
        if result:
            for row in result:
                event = DeviceEvent(row['eventtypeid'], row['alerttype'])
                event.alerthistid = row['alerthistid']
                event.source = row['source']
                event.deviceid = row['deviceid']
                event.netboxid = row['netboxid']
                event.subid = row['subid']
                event.start_time = row['start_time']
                event.end_time = row['end_time']
                event.value = row['value']
                event.severity = row['severity']

                # get alerthistvars
                sql = """
SELECT state, var, val
FROM alerthistvar
WHERE alerthistid='%s'""" % event.alerthistid
                database.execute(sql)
                vars = database.dictfetchall()
                if vars:
                    for var in vars:
                        event.addVar(var['var'], var['val'], var['state'])

                # get alerthistmsgs
                sql = """
SELECT state, msg
FROM alerthistmsg
WHERE msgtype='sms' AND language='en' AND alerthistid='%s'""" % \
                    event.alerthistid
                database.execute(sql)
                msgs = database.dictfetchall()
                if msgs:
                    for msg in msgs:
                        event.addMsg(msg['msg'], msg['state'])

                events.append(event)
        return events