np_treestats.py

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

                     or what.find('Delays') >= 0 \
                     or  what.find('Attempts') >= 0:
                    dels = self.cdelays
                    conns = get_conns_from_plist(pages)
                    print conns
                    print
                    print
                    self.show_delays([(c, dels[c][0]) for c in conns], what)
                else:
                    raise CallBackError( 'Unknown Pages-by-frequency draw type \'%s\'' % (what))

            elif m[2].find('Server-by-delay') >= 0:
                ad = obdict[m[0]][0]
                conns = obdict[m[0]][1]
                if what == 'Connections':
                    #conns = self.sdict[ad]
                    clist.extend(\
                        [obdict[c].reconstruct(trace=1) for c in conns])
                else:
                    pages = [p for p in self.pagelist if p[4] == ad]

                    if what.find('Page-delays') >= 0:
                        if what.find('per_object') >= 0:
                            po = 1
                        else:
                            po = 0
                        self.show_page_delays(pages, po)
                    elif what == 'Page':
                        make_pages(pages)
                    elif what == 'All Pages':
                        make_all_pages(pages)
                    elif what.find('Page Times') >= 0:
                        if what.find('less delays') >= 0:
                            pti = 2
                            label = 'Page download times less delays'
                        else:
                            pti = 1
                            label = 'Page download times'
                        if what.find('85%') >= 0:
                            pti += 2
                            label = '85% ' + label
                        ptlist.extend(get_ptlist_from_plist(pages, None))
                    elif what.find('Retransmits') >= 0 \
                         or what.find('Delays') >= 0 \
                         or  what.find('Attempts') >= 0:
                        #conns = get_conns_from_plist(pages)
                        dels = self.cdelays
                        self.show_delays([(c, dels[c][0]) for c in conns], what)
                    else:
                        raise CallBackError('Unknown Server-by-delay draw type \'%s\''  % (what))

            
            elif m[2].find('Rank') == 0:
                #raise CallBackError('Rank')
                pages = obdict[m[0]]
                #rtype = recons_type(m[2])
                #conns = get_conns_from_plist(obdict[m[0]][1])
                #ad = obdict[m[0]][0]
                #print conns
                if what == 'Connections':
                    conns = get_conns_from_plist(pages)
                    clist.extend(\
                        [obdict[id].reconstruct(trace=1) for id in conns])
                elif what == 'Page':
                    make_pages(pages)
                elif what == 'All Pages':
                    make_all_pages(pages)   
                elif what.find('Page Times') >= 0:
                    if what.find('less delays') >= 0:
                        pti = 2
                        label = 'Page download times less delays'
                    else:
                        pti = 1
                        label = 'Page download times'
                    if what.find('85%') >= 0:
                        pti += 2
                        label = '85% ' + label
                    ptlist.extend(get_ptlist_from_plist(self.pagelist, None))

                elif what.find('Page-delays') >= 0:
                    if what.find('per_object') >= 0:
                        po = 1
                    else:
                        po = 0
                    self.show_page_delays(pages, po)
                    
                elif what.find('Retransmits') >= 0 \
                     or what.find('Delays') >= 0 \
                     or  what.find('Attempts') >= 0:
                    dels = self.cdelays
                    conns = get_conns_from_plist(pages)
                    self.show_delays([(c, dels[c][0]) for c in conns], what)
                    
                else:
                    raise CallBackError('Unknown Rank Client draw type \'%s\'' % (what))

            elif m[2].find('All page times') == 0:
                if what.find('Page-delays') >= 0:
                    if what.find('per_object') >= 0:
                        po = 1
                    else:
                        po = 0
                    self.show_page_delays(self.pagelist, po)
                    return
                passfn = self.obdict[m[1]]
                ptlist.extend(get_ptlist_from_plist(self.pagelist, passfn))
                label = m[2]
                if what.find('Page Times less delays') >= 0:
                    pti = 2
                elif what.find('Page Times') >= 0:
                    pti = 1
                if what.find('85%') >= 0:
                    pti += 2
                    label = '85% ' + label
                if what.find('per-object') >= 0:
                    ptdiv = 1

            elif m[2].find('Delays') >= 0 or m[2].find('Retransmits') >= 0 \
                     or  m[2].find('Attempts') >= 0:
                #self.show_delays(self.cdelays, what)
                self.show_delays([(c[0], c[1][0]) for c in self.cdelays.items()], what)

            else:
                raise CallBackError('Unknown draw type \'%s\'' % (m[2]))

        if len(tlist) and what in ['Page', 'All Pages']:
            Tscreen(tlist, lookup=lookup2, standalone='no', trace=1)

        if len(clist) and what == 'Connections':
            for c in clist:
                c.adjust_tm_offsets(c.abstart)
            TcpDisplay(clist, standalone='no', logfun=self.nullf, trace=0)

        if len(ptlist):
            data = []
            i = 0
            for e in ptlist:
                rtype = e[0]
                ad = e[2]
                for page in e[1]:
                    #print 'page=', page
                    tms = page[7]
                    wtm = tms[pti]
                    if ptdiv:
                        wtm /= page[6]
                    conns = tuple(page[8])
                    url = (page[0], page[1])
                    #
                    # make the taglist element of tuple to avoid
                    # nplot drag-select from coalescing values
                    data.append([tms[0], wtm, i,
                                 ((rtype, conns, url, ad),)])
                i += 1
            #print '\n\nData\n', data
            ds = DataSet(data, DATA_TS, '', None, callback=self.show_page)
            np_Plot([ds], standalone='no', path=self.obdict['filepath'],
                    title=label, xlab='elapsed time s',
                    ylab='Page\ndownload\ns')
                    

        #print self.curr_show[2]

#############################################################################

    def prob_per(self, data, per, label, nbts, low, firstag):

        #
        # Compute probability of N occurences over period per
        #

        data.sort()
        #print data
        

        nbkts = 10
        nbkts = nbts
        dout = [[], [], [], [], [], [], [], [], [], [], []]
        show = array('f', [0]*(nbkts+1))
        cts = array('i', [0]*(nbkts+1))
        #gt = 0

        #print dout

        start = data[0][0]
        xt = start + per
        n = 0
        for d in data:
            tm = d[0]
            v = d[1]
            ns = d[2]

            if tm > xt:
                #print cts, n
                for i in range(nbkts+1):
                    if n:
                        p = float(cts[i])/n
                    else:
                        p = 0.0
                    dout[i].append([xt, p])
                    show[i] += p
                    cts[i] = 0
                #for i in range(nbkts+1):
                    #print dout[i]
                #raw_input('...')
                n = 0
                xt += per
                while xt < tm:
                    for i in range(nbkts+1):
                        dout[i].append([xt, 0.0])
                    xt += per

            n += ns
            if v < nbkts:
                cts[v] += 1
            else:
                cts[nbkts] += 1

        # any in final interval?
        if n:
            for i in range(nbkts+1):
                p = float(cts[i])/n
                dout[i].append([xt, p])
                show[i] += p


        data = []
        for i in range(low, nbkts):
            if show[i]:
                lab = '%d %s' % (i, label) # -1 as want retransmits
                data.append(DataSet(dout[i], DATA_TS, lab, firstag))
                firstag += 1
        if show[i+1]:
            lab = 'gt. %d %s' % (i, label)
            data.append(DataSet(dout[i], DATA_TS, lab, firstag))
            firstag += 1
                
        return (firstag, data)
        

#############################################################################

    def do_del_prob(self, delay_list, what):
        
        #
        # Plot P connection delays
        #

        syns = []
        syns_nc = []
        freq = []
        req = []
        noreq = []
        norep = []

        dups = 0
        freqr = 0
        reqr = 0
        nreq = 0
        synnc = 0
        nrep = 0
        

        for d in delay_list:
            dd = d[1]
            tm = dd[0]
            nfpkts = dd[1]
            if len(dd) == 3:
                dels = dd[2]
                flags = dels[-1]
                if not (flags & D_BIGDEL):
                    continue
                reqri = 0
                syni = 0
                norepi = 0
                if flags & D_DUPFREQ:
                    freq.append([tm, dels[0]+1, 1])
                    reqri += 2
                    syni += 2
                    freqr = 1
                else:
                    freq.append([tm, 1, 1])
                    if flags & D_REQNOTSEEN and not (flags & D_NOT_CONNECTED):
                        noreq.append([tm, dels[syni], 0, [id]])
                        reqri += 2
                        syni += 2
                        norepi += 2
                        nreq = 1
                    else:
                        noreq.append([tm, 0, 1])
                if flags & D_CRETRANS:
                    req.append([tm, dels[reqri], nfpkts])
                    syni += 2
                    norepi += 2
                    reqr = 1
                else:
                    req.append([tm, 0, nfpkts])
                    
                if flags & D_DUPCSYN:
                    norepi += 2
                    if flags & D_NOT_CONNECTED:
                        syns_nc.append([tm, dels[syni]+1, 1])
                        syns.append([tm, 1, 1])
                        synnc = 1
                    else:
                        syns.append([tm, dels[syni]+1, 1])
                        syns_nc.append([tm, 0, 1])
                        dups = 1
                else:
                    syns.append([tm, 1, 1])
                    #syns_nc.append([tm, 0, 1])
                    if flags & D_NOT_CONNECTED:
                        norepi += 2
                        syns_nc.append([tm, 1, 1])
                        synnc = 1
                    else:
                        syns_nc.append([tm, 0, 1])

                if flags & D_REPNOTSEEN and not (flags & D_REQNOTSEEN):
                    norep.append([tm, dels[norepi], 1])
                else:
                    norep.append([tm, 0, 1])

                
            else:
               freq.append([tm, 1, 1])
               req.append([tm, 0, nfpkts])
               syns.append([tm, 1, 1])
               syns_nc.append([tm, 1, 1])
               noreq.append([tm, 0, 1])
               norep.append([tm, 0, 1])
               
        data = []

        if what.find('Retransmits-P') >= 0:

            try:
                per = self.get_per(what)
            except:
                print 'Don\'t understand P period in \'%s\' - using 1s' % (what)
                per = 1

            firstag = 0
            nbkts = 3
            low = 1

            if freqr:
                nbkts = 3
                firstag, d = self.prob_per(freq, per,
                               'first object requests', nbkts, low, firstag)
                data.extend(d)
            if reqr:
                nbkts = 2
                firstag, d = self.prob_per(req, per,
                               'following object packet retransmission', nbkts,
                                           low, firstag)
                data.extend(d)
            if dups:
                nbkts = 4
                firstag, d = self.prob_per(syns, per, 'SYNs', nbkts, low, firstag)
                data.extend(d)
            if synnc:
                nbkts = 3
                firstag, d = self.prob_per(syns_nc, per,
                           'SYNs - connection not accepted', nbkts, low, firstag)
                data.extend(d)

            nbkts = 2

            if nreq:
                nbkts = 2
                firstag, d = self.prob_per(noreq, per,
                           'No request made on connection', nbkts, low, firstag)
                data.extend(d)

            if nrep:
                nbkts = 2
                firstag, d = self.prob_per(norep, per,
                           'No server response', nbkts, low, firstag)
                data.extend(d)



            if data:
                title = 'Probability over %ds periods' % (per)
                np_Plot(data, standalone='no', path=self.obdict['filepath'],
                        title=title, xlab='elapsed time s',
                        ylab='Probability')

        #elif what.find('Attempts-all') >= 0:
        elif what.find('At