np_obtree.py

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

                    ccolour = self.tdict[cobtype][1]
                else:
                    ccolour = 'grey72'

		#draw request
		xreqstart = req.xvreqstart = self.leftmargin +int(reqstart*scalef)
		if reqdur:
		    xreqend = req.xvreqend = xreqstart + int(reqdur*scalef)
		else:
		    xreqend = req.xvreqend = xreqstart
		RECT(xreqstart, y0, xreqend, ycentre, fill=ccolour, 
		     outline=ccolour, width=2)
	    else:
		xreqstart = xreqend = 0


	    #if req.svalid:
	    if 1: ###
		repstart = req.repstart
		repend = req.repend
		repdur = req.repdur
		sobtype = req.sobtype
                if dist:
                    scolour = self.tdict[sobtype][1]
                else:
                    scolour = 'grey72'

		#draw response
		xrepstart = req.xvrepstart = self.leftmargin +int(repstart*scalef)
		if repdur:
		    xrepend = req.xvrepend = xrepstart + int(repdur*scalef)
		else:
		    xrepend = req.xvrepend = xrepstart
		RECT(xrepstart, ycentre, xrepend, y1, fill=scolour, 
		     outline=scolour, width=2)
                repdel = req.delrepend - repend
                #if repdel:
                    #xdelrepend = xrepend + int(repdel*scalef)
                    #RECT(xrepend, ycentre, xdelrepend, y1, 
                         #outline=scolour, width=1)
	    else:
		xrepstart = xrepend = 0

            self.label_req(canv, req, xreqstart, xreqend, xrepstart, 
			   xrepend, y0, ycentre, y1, dist)

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

    def draw_gaps(self):
	
	gaps = self.gaps
	canv = self.draw
	tcanv = self.drawscale
	TEXT = tcanv.create_text
	LINE = canv.create_line
	TLINE = tcanv.create_line
	#scalef = canv.scalef
	scalef = self.draw.scalef

	#print 'drawing %d gaps' % (len(gaps))

	totgap = 0
	ngaps = 0
	y0 = self.toplabely
	y1 = self.scaleht
	#y3 = self.draw.yrange
        y3 =  canv.ymin
	y4 = canv.ymax

        if not len(gaps):
            tcanv.ysize = self.scaleht
            return

	# find largest gap label and calculate scale steps to stop trampling
	t = TEXT(0, 0, anchor=W, fill='black', font=self.font10, text='%d' % (gaps[-1][1]/1000))
	bb=tcanv.bbox(t)
	mtw = bb[2] - bb[0] + 5
	tcanv.delete(t)
	steps = mtw/self.mingapx

        tsep = self.gap_text_ysep

	for gap in gaps:
	    #print gap
	    type = gap[0]
	    tm = gap[1]
	    g = gap[2]

	    #print '%9d %8d %d' % (tm/1000, g/1000, type)
	    x1 = self.leftmargin \
		 + int((tm - totgap)*scalef) + ngaps*self.gapwidth
	    x2 = x1 + self.gapwidth
	    x = x1 + self.gapwidth/2
	    gap[3] = x
	    if type == GAP_TM:
		colour = "azure2"
		tcolour = 'black'
	    elif type == GAP_CONNS:
		colour = "PaleTurquoise1"
		tcolour = 'RoyalBlue'
	    else:
		colour = "DarkSeaGreen1"
		tcolour = 'DarkSeaGreen4'


	    # Sanity
	    if g < 0:
		print 'WHOOPS negative gap (%d-%d)' % (tm/1000, (tm+g)/1000)
		colour="red"

	    down = ngaps%steps
	    texty = y0 + down*tsep
	    #if texty > maxdown:
		#maxdown = texty

	    startstr = '%d' % (tm/1000)
	    endstr = '%d' % ((tm+g)/1000)
	    #self.draw_dotted_vline(canv, x, y0, y1, colour)
	    TLINE(x, texty, x, y1, fill=colour)
	    l = LINE(x, y3, x, y4, fill=colour)
            canv.lower(l)
	    TEXT(x1, texty, fill=tcolour, anchor=E,
				  text = startstr, font=self.font10)
	    TEXT(x2, texty, fill=tcolour, anchor=W,
				  text = endstr, font=self.font10)
	    totgap = totgap + g
	    ngaps = ngaps+1

	bb = tcanv.bbox(ALL)
	tcanv.ysize = bb[3]-bb[1]+10

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

    def draw_implied_objects(self):
        
	width = self.min_x
	canv = self.draw
	TEXT = canv.create_text
        col = 'black'
        tconns = self.client.connlist
        
        canv.dummytrans_map = {}
        
	for req in self.client.dummytrans:

            if self.rooturl and not req in self.tree_trans:
                draw_me = 0
                for t in req.downlinks:
                    if t in self.tree_trans:
                        draw_me = 1
                if not draw_me:
                    continue

##             # distinguished?
##             if self.rooturl and self.rooturl != req.absurl:
##                 col = 'grey72'
##             else:
##                 col = 'black'
                
	    req.xreqstart = req.xrepstart = req.firstrans.xreqstart - width/2
	    req.xreqend = req.xrepend = req.xreqstart + width

            # find nearest convenient y location
            if self.connht > 50:
                y = req.firstrans.TConn.y - self.conncentre
                i = None
            else:
                i = req.firstrans.TConn.indx - 1
                while i >= 0:
                    if tconns[i].maxx < req.xreqstart:
                        break
                    i -= 1
                    
                if i < 0:
                    for s in self.client.dummytrans:
                        if not canv.dummytrans_map.has_key(i) or canv.dummytrans_map[i] < req.xreqstart:
                            break
                        i -= 1
                    y = canv.topy + i*self.connht + self.topmargin
                else:
                    y = tconns[i].y
            
            req.y = y
	    y0 = req.y0 = req.y-self.reqht/2
	    y1 = req.y1 = req.y0+self.reqht
	    self.draw.create_rectangle(req.xreqstart, y0, req.xreqend, y1, 
				       outline=col, width=2)

	    #label object
	    labelstr = req.obname
	    t = TEXT(req.xreqstart+10, (y0+y1)/2, fill=col, anchor=W, 
		       text='>%d' % (-req.order), font = self.font10bold)
          ##   # if distinguished tree root mark it
##             if self.rooturl == req.absurl:
##                 bb = canv.bbox(t)
##                 canv.create_rectangle(bb[0], bb[1], bb[2], bb[3],
##                                       outline='red')
	    t = TEXT(canv.bbox(t)[2]+5, (y0+y1)/2, fill=col, anchor=W, 
				  text=labelstr, font = self.font10)
            if i != None:
                # record this so not over-written later
                if i >= 0:
                    tconns[i].maxx = max(tconns[i].maxx, canv.bbox(t)[2])
                else:
                    canv.dummytrans_map[i] = canv.bbox(t)[2]
#############################################################################

    def draw_implied_objects_v(self):
        
	width = self.min_x
        canv = self.view
	TEXT = canv.create_text
        col = 'black'
        tconns = self.client.connlist
        
        canv.dummytrans_vmap = {}
        
	for req in self.client.dummytrans:
            #print '#%d ' % (req.order),

            if self.rooturl and not req in self.tree_trans:
                draw_me = 0
                for t in req.downlinks:
                    if t in self.tree_trans:
                        draw_me = 1
                if not draw_me:
                    continue

            

##             # distinguished?
##             if self.rooturl and self.rooturl != req.absurl:
##                 col = 'grey72'
##             else:
##                 col = 'black'
                
	    req.xvreqstart = req.xvrepstart = req.firstrans.xvreqstart - width/2
	    req.xvreqend = req.xvrepend = req.xvreqstart + width

            # find nearest convenient y location
            if self.connht > 50:
                y = req.firstrans.TConn.vy - self.conncentre
                i = None
            else:
                i = req.firstrans.TConn.indx - 1
                #print 'i start = %d ' % (i),
                while i >= 0:
                    if tconns[i].maxvx < req.xvreqstart:
                        break
                    i -= 1
                    
                if i < 0:
                    for s in self.client.dummytrans:
                        #print 'XVXV ',
                        #print req.order
                        if not canv.dummytrans_vmap.has_key(i) or canv.dummytrans_vmap[i] < req.xvreqstart:
                            break
                        i -= 1
                    y = canv.topy + i*self.connht + self.topmargin
                else:
                    y = tconns[i].vy

            #if i != None:
                #print 'at indx %d' % (i)
            req.yv = y
	    y0 = req.yv0 = req.yv-self.reqht/2
	    y1 = req.yv1 = req.yv0+self.reqht
	    canv.create_rectangle(req.xvreqstart, y0, req.xvreqend, y1, 
				       outline=col, width=2)

	    #label object
	    labelstr = req.obname
	    t = TEXT(req.xvreqstart+10, (y0+y1)/2, fill=col, anchor=W, 
			 text='>%d' % (-req.order), font = self.font10bold)
          ##   # if distinguished tree root mark it
##             if self.rooturl == req.absurl:
##                 bb = canv.bbox(t)
##                 canv.create_rectangle(bb[0], bb[1], bb[2], bb[3],
##                                       outline='red')
	    t = TEXT(canv.bbox(t)[2]+5, (y0+y1)/2, fill=col, anchor=W, 
				  text=labelstr, font = self.font10)
            if i != None:
                if i >= 0:
                    tconns[i].maxvx = max(tconns[i].maxvx, canv.bbox(t)[2])
                    #print '%d - adj maxvx' % (i)
                else:
                    canv.dummytrans_vmap[i] = canv.bbox(t)[2]

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

    def draw_link(self, canv, fx, fy, tx, ty, type, obsepy, obwi):


	LINE = canv.create_line

	self.LinkDict['types-seen'] += 1
	style = self.get_linktype(type)
        style[0] += 1
	colour = style[2]
	st = style[3]

        if ty == fy:
            # same level
            thisy = fy - obsepy/2
            LINE(fx, thisy, tx, thisy, fill=colour, stipple=st)
            LINE(fx, thisy, fx, fy-obwi, fill=colour, stipple=st)
            LINE(tx, thisy, tx, ty-obwi, fill=colour, stipple=st)
            LINE(tx, ty-obwi-1, tx, ty-obwi, fill=colour,
                 arrow="last", arrowshape=(4,5,2))
        elif ty > fy:
            # object lower than referrer
            thisy = fy + obsepy/2
            #print 'object lower - thisy %d' % (thisy)
            LINE(fx, thisy, tx, thisy, fill=colour, stipple=st)
            LINE(fx, thisy, fx, fy + obwi, fill=colour, stipple=st)
            LINE(tx, thisy, tx, ty - obwi, fill=colour, stipple=st)
            LINE(tx, ty-obwi-1, tx, ty - obwi, fill=colour,
                 arrow="last", arrowshape=(4,5,2))
        else:
            # object higher than referrer
            thisy = fy - obsepy/2
            #print 'object higher - thisy %d' % (thisy)
            LINE(fx, thisy, tx, thisy, fill=colour, stipple=st)
            LINE(fx, thisy, fx, fy - obwi, fill=colour, stipple=st)
            LINE(tx, thisy, tx, ty + obwi, fill=colour, stipple=st)
            LINE(tx, ty+obwi+1, tx, ty + obwi, fill=colour, arrow="last", 
                 arrowshape=(4,5,2))

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

    def draw_deps(self, canv, obsepy, obwi):

	def find_pkt(pktlist, time):
	    for pkt in pktlist:
		if pkt.tm == time:
		    return pkt
            return None

## 	def find_pkt(conn, time):
##             try:
##                 return self.pktdict[conn, time]
##             except KeyError:
##                 return None
        translist = self.client.translist + \
                    [d for d in self.client.dummytrans if d.reflink]
    
        for trans in translist:
            if trans.reflink \
                   and ((not self.rooturl) or trans in self.tree_trans):
                link = trans.reflink
                ref = link.trans
                type = link.type

                if (type & (LR_INLINE | LR_LINK)) and ref.TConn:
                    pkt = find_pkt(ref.TConn.pktlist, link.tm)
                    #pkt = find_pkt(ref.TConn, link.tm)
                    if not pkt:
                        print 'No pkt found trans', trans.order
                        print link
                        #raw_input('...')
                        continue
                        
                    if canv == self.draw:
                        refx = pkt.pktx
                        obx = trans.xreqstart
                        refy = ref.y
                        oby = trans.y
                    else:
                        refx = pkt.pktvx
                        obx = trans.xvreqstart
                        refy = ref.yv
                        oby = trans.yv

                else:
                    ## try is tmp for debugging
                    try:
                        if canv == self.draw:
                            refx = (ref.xrepstart+ref.xrepend)/2
                            obx = trans.xreqstart
                            refy = ref.y
                            oby = trans.y
                        else:
                            refx = (ref.xvrepstart+ref.xvrepend)/2
                            obx = trans.xvreqstart
                            refy = ref.yv
                            oby = trans.yv
                    except AttributeError, s:
                        print s
                        print 'Client %s connid %d trans %d cflags=%x sflags=%x' % (intoa_string(self.client.id), trans.TConn.id, trans.order, trans.cstatus, trans.sstatus)
                        print 'link type %x' % (type)
                        print ref, ref.connid, ref.order
                        #trans.TConn.printself_with_trans()
                        raw_input('...')
                        break
                        

                self.draw_link(canv, refx, refy, obx, oby, type, obsepy, obwi)
            
            

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

    def draw_scale(self):

	canv = self.view
	scanv = self.viewscale
	TEXT = scanv.create_text
	LINE = canv.create_line
	TLINE = scanv.create_line

	scalef = self.view.scalef

	# calculate scale width and units
	t = int(self.minscalewidth/scalef)
	inc = 1
	while 1:
	    if inc > t:
		break
	    inc = inc*10

	
	lastdelta = abs(inc - t)
	for scale in [2,4,10]:
	    thisinc = inc/scale
	    delta = abs(thisinc - t)
	    if delta > lastdelta:
		break
	    lastdelta = delta
	    inc = thisinc