np_act.py

该软件根据网络数据生成NetFlow记录。NetFlow可用于网络规划、负载均衡、安全监控等

            # bandwidths
            wmbs = pr.wire_mbs
            w_max_wmbs = max([wmbs, w_max_wmbs])
            w_wire_bw.append([ts, wmbs])
            
            tmbs = pr.tcp_mbs
            w_max_tmbs = max([tmbs, w_max_tmbs])
            w_tcp_bw.append([ts, tmbs])
            
            umbs = pr.udp_mbs
            w_max_umbs = max([umbs, w_max_umbs])
            w_udp_bw.append([ts, umbs])
            
            hmbs = pr.http_mbs
            #print hmbs
            w_max_hmbs = max([hmbs, w_max_hmbs])
            w_http_bw.append([ts, hmbs])
            
            hparsed  = float(ul2l(pr.get_html_parsed()))/per
            #print hparsed
            w_max_hparsed = max([hparsed, w_max_hparsed])
            w_html_parse.append([ts, hparsed])

            # packet rates
            p = float(ul2l(pr.get_wire_pkts()))
            w_max_wpps = max([w_max_wpps, p])
            w_wire_pkts.append([ts, p])
            
            p = float(ul2l(pr.get_tcp_pkts()))
            w_max_tpps = max([w_max_tpps, p])
            w_tcp_pkts.append([ts, p])
            
            p = float(ul2l(pr.get_udp_pkts()))
            w_max_upps = max([w_max_upps, p])
            w_udp_pkts.append([ts, p])
            
            p = float(ul2l(pr.get_http_pkts()))
            w_max_hpps = max([w_max_hpps, p])
            w_http_pkts.append([ts, p])

            

        elif rectype == REC_PERIOD_REPORT:
            pr.read_reprec(file, ru, 1)

            #
            # rusage stuff
            #
            uts = tv2l(ru.get_ts())
            if first_ts == 0:
                first_ts = uts
            utm = tv2l(ru.get_utime()) # user time
            stm = tv2l(ru.get_stime()) # system time

            this_utm = utm - last_utm
            this_stm = stm - last_stm
            ru_per = uts - last_uts

            upct = (float(this_utm)*100)/ru_per
            spct = (float(this_stm)*100)/ru_per

            #print '%.2f' % (pct)
            tm = (uts-first_ts)/1000000
            urusage.append([tm, upct])
            srusage.append([tm, spct])
            trusage.append([tm, upct+spct])

            last_utm = utm
            last_stm = stm
            last_uts = uts

##
## Linux rusage doesn't record these
##

##             m = float(ru.max_rss())
##             #print 'rss ', ; print m
##             m = m/1000
##             max_maxrss = max([m, max_maxrss])
##             maxrss.append([tm, m])

##             m = ru.majflt()
##             #print 'majflt ', ; print m
##             n = m - last_majflt
##             last_majflt = m
##             max_majflt = max([n, max_majflt])
##             majflt.append([tm, n])

##             m = ru.nswap()
##             #print 'swap ', ; print m
##             n = m - last_nswap
##             last_nswap = m
##             max_nswap = max([n, max_nswap])
##             nswap.append([tm, n])

##             m = ru.blkio()
##             #print 'blkio ', ; print m
##             n = m - last_blkio
##             last_blkio = m
##             max_blkio = max([n, max_blkio])
##             blkio.append([tm, n])

##             m = ru.cswitches()
##             #print 'cswitches ', ; print m
##             n = m - last_cswitches
##             last_cswitches = m
##             max_cswitches = max([n, max_cswitches])
##             cswitches.append([tm, n])

            #
            # stats stuff
            #
            rts = tv2l(pr.get_ts())
            if first_ts == 0:
                first_ts = rts
            per = rts - last_rts
            last_rts = rts
            ts = float(rts - first_ts)/1000000
            #print ts

            # bandwidths
            wmbs = pr.wire_mbs
            max_wmbs = max([wmbs, max_wmbs])
            wire_bw.append([ts, wmbs])
            
            tmbs = pr.tcp_mbs
            max_tmbs = max([tmbs, max_tmbs])
            tcp_bw.append([ts, tmbs])
            
            umbs = pr.udp_mbs
            max_umbs = max([umbs, max_umbs])
            udp_bw.append([ts, umbs])
            #print umbs, max_umbs
            
            hmbs = pr.http_mbs
            #print hmbs
            max_hmbs = max([hmbs, max_hmbs])
            http_bw.append([ts, hmbs])
            
            hparsed  = float(ul2l(pr.get_html_parsed()))/per
            #print hparsed
            max_hparsed = max([hparsed, max_hparsed])
            html_parse.append([ts, hparsed])

            # packet rates
            p = float(ul2l(pr.get_wire_pkts()))
            max_wpps = max([max_wpps, p])
            wire_pkts.append([ts, p])
            
            p = float(ul2l(pr.get_tcp_pkts()))
            max_tpps = max([max_tpps, p])
            tcp_pkts.append([ts, p])
            
            p = float(ul2l(pr.get_udp_pkts()))
            max_upps = max([max_upps, p])
            udp_pkts.append([ts, p])
            
            p = float(ul2l(pr.get_http_pkts()))
            max_hpps = max([max_hpps, p])
            http_pkts.append([ts, p])

            #write_rates
            repwritten = float(ul2l(pr.get_rep_bytes_written()))/1000
            max_repwritten = max([repwritten, max_repwritten])
            rwritten.append([ts, repwritten])
            #print repwritten,  max_repwritten 
            
            dumpwritten = float(ul2l(pr.get_dump_bytes_written()))/1000
            max_dumpwritten = max([dumpwritten, max_dumpwritten])
            dwritten.append([ts, dumpwritten])
            #print dumpwritten,  max_dumpwritten
            
            d = (repwritten+dumpwritten)
            max_twritten = max([d, max_twritten])
            twritten.append([ts, d])
            #print d,  max_twritten
            #print '-----------'

            # dump rates
            repdumped = (float(ul2l(pr.get_rep_blks_dumped()))*WRITE_BLKSZ)/1000
            max_repdumped = max([repdumped, max_repdumped])
            rdumped.append([ts, repdumped])
            #print repdumped,  max_repdumped 
            
            dumpdumped = (float(ul2l(pr.get_dump_blks_dumped()))*WRITE_BLKSZ)/1000
            max_dumpdumped = max([dumpdumped, max_dumpdumped])
            ddumped.append([ts, dumpdumped])
            #print dumpdumped,  max_dumpdumped
            
            d = (repdumped+dumpdumped)
            max_tdumped = max([d, max_tdumped])
            tdumped.append([ts, d])
            #print d,  max_tdumped
            #print '-----------'
            
            # other stuff
            mfi = float(ul2l(pr.get_max_fetch_interval()))/1000
            max_mfi = max([mfi, max_mfi])
            max_fetch_int.append([ts, ul2l(mfi)])

            bh = pr.buff_held
            max_bheld = max([bh, max_bheld])
            bheld.append([ts, bh])

            nf = pr.buf_alloc_fails
            max_fails = max([max_fails, nf])
            fails.append([ts, nf])

            v = pr.get_tcp_to()
            if v < 0:
                v = ul2l(v)
            max_tcp_to = max([max_tcp_to, v])
            tcp_to.append([ts, v])

            v = pr.get_udp_to()
            if v < 0:
                v = ul2l(v)
            max_udp_to = max([max_udp_to, v])
            udp_to.append([ts, v])

            seq_to = 0L
            v = pr.get_tcp_seq_to()
            if v < 0:
                v = ul2l(v)
            seq_to += v
            v = pr.get_tcp_seq_to_forced()
            if v < 0:
                v = ul2l(v)
            seq_to += v
            v = pr.get_tcp_seq_to_q()
            if v < 0:
                v = ul2l(v)
            seq_to += v
            v = pr.get_tcp_seq_to_ack()
            if v < 0:
                v = ul2l(v)
            seq_to += v

            max_tcp_seq_to = max([max_tcp_seq_to, seq_to]) 
            tcp_seq_to.append([ts, float(seq_to)])
            
            v = float(ul2l(pr.get_IP_ulen()))
            #print v
            max_IP_ulen = max([max_IP_ulen, v])
            IP_ulen.append([ts, v*1000000/per])

            v = ul2l(pr.get_tous_in())
            p = (float(v - last_tous_in)*1000000)/per
            last_tous_in = v
            max_tous_in = max([p, max_tous_in])
            tous_in.append([ts, p])

            v = float(ul2l(pr.get_tous_out()))
            p = (float(v - last_tous_out)*1000000)/per
            last_tous_out = v
            max_tous_out = max([p, max_tous_out])
            tous_out.append([ts, p])

            v = float(ul2l(pr.get_frus_in()))
            p = (float(v - last_frus_in)*1000000)/per
            last_frus_in = v
            max_frus_in = max([p, max_frus_in])
            frus_in.append([ts, p])

            v = float(ul2l(pr.get_frus_out()))
            p = (float(v - last_frus_out)*1000000)/per
            last_frus_out = v
            max_frus_out = max([p, max_frus_out])
            frus_out.append([ts, p])
            
            

        elif rectype == REC_WRAPPER:
            #print 'wrapper'
            wr.read(file)
##             if wr.type == WRAPPER_TIME_CALLS:
##                 #
##                 # Call times stuff
##                 #
##  ##                ts = tv2l(wr.get_ts())
##                 per = ts - last_times_ts
##                 last_times_ts = ts
##                 ts = float(ts - first_ts)/1000000

##                 # IP
##                 v = ull2l(wr.get_ip_usrtm())
##                 #print v
##                 pc = (float(v)*100)/per
##                 #print pc
##                 max_times_ip_uusage = max([max_times_ip_uusage, pc])
##                 times_ip_uusage.append([ts, pc])
                
##                 v = ull2l(wr.get_ip_systm())
##                 #print v
##                 pc = (float(v)*100)/per
##                 #print pc
##                 max_times_ip_susage = max([max_times_ip_susage, pc])
##                 times_ip_susage.append([ts, pc])

##                 # UDP
##                 v = ull2l(wr.get_udp_usrtm())
##                 #print v
##                 pc = (float(v)*100)/per
##                 #print pc
##                 max_times_udp_uusage = max([max_times_udp_uusage, pc])
##                 times_udp_uusage.append([ts, pc])
                
##                 v = ull2l(wr.get_udp_systm())
##                 #print v
##                 pc = (float(v)*100)/per
##                 #print pc
##                 max_times_udp_susage = max([max_times_udp_susage, pc])
##                 times_udp_susage.append([ts, pc])

##                 # TCP
##                 v = ull2l(wr.get_tcp_usrtm())
##                 #print v
##                 pc = (float(v)*100)/per
##                 #print pc
##                 max_times_tcp_uusage = max([max_times_tcp_uusage, pc])
##                 times_tcp_uusage.append([ts, pc])
                
##                 v = ull2l(wr.get_tcp_systm())
##                 #print v
##                 pc = (float(v)*100)/per
##                 #print pc
##                 max_times_tcp_susage = max([max_times_tcp_susage, pc])
##                 times_tcp_susage.append([ts, pc])

##                 # TCP_INSEQ
##                 v = ull2l(wr.get_tcp_inseq_usrtm())
##                 #print v
##                 pc = (float(v)*100)/per
##                 #print pc
##                 max_times_tcp_inseq_uusage = max([max_times_tcp_inseq_uusage, pc])
##                 times_tcp_inseq_uusage.append([ts, pc])
                
##                 v = ull2l(wr.get_tcp_inseq_systm())
##                 #print v
##                 pc = (float(v)*100)/per