histo.py

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

            upper = max(self.extends)
        else:
            h =  self.saved[-1]
            t = type(h)
            if t is TupleType or t is ListType:
                h = h[0]
            upper  = h

        self.upper = upper
        
        range = upper - lower

        #
        # inclusive upper bound is set - recalculate lower bound to accomodate
        # chosen nbuckets and width.
        # One bucket is added if auto-ranging to accomodate lowest value
        #
        
        if self.bucketsz:
            self.nbuckets = int(ceil(range/float(self.bucketsz))) + autorange
            self.lower = upper - (self.nbuckets*self.bucketsz)
        else:
            if not self.floating and range % self.nbuckets:
                self.floating = 1
            if self.floating:
                self.bucketsz = range/float(self.nbuckets)
            else:
                self.bucketsz = int(ceil(range/float(self.nbuckets)))
            self.nbuckets += autorange
            self.lower = upper - (self.nbuckets*self.bucketsz)
                
        l = [0]*self.nbuckets
        self.ha = array('L', l)

        # add any saved values
        add = self.addval
        for val in self.saved:
            add(self.getval(val), val)

        self.saved = []

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

    def extend(self, val, addval=1):

        v = self.getval(val)

        if self.lower < v <= self.upper:
            if v > self.lower:
                raise HistogramError('Extend on value %s >= lower bound %s' % (v, self.lower))
            else:
                raise HistogramError('Extend on value %s < upper bound %s' % (v, self.upper))

        if self.ha: # histogram is running - extend immediately

            if v > self.upper:
                hold = self.upper
                ext = v-self.upper
                nb = max(1, int(ceil(ext/float(self.bucketsz))))
                l = [0]*nb
                a = array('L', l)
                self.ha.extend(a)
                self.nbuckets += nb
                self.upper += (nb*self.bucketsz)
                if self.verbose:
                    print 'extending upper %s->%s %d buckets' % (str(hold), str(self.upper), nb)

            else:
                hold = self.lower
                ext = self.lower - v
                nb = max(1, int(ceil(ext/float(self.bucketsz))))
                self.lower -= (nb*self.bucketsz)
                # allow for v == lower (lower is non-inclusive)
                if v == self.lower:
                    nb += 1
                    self.lower -= self.bucketsz
                l = [0]*nb
                a = array('L', l)
                a.extend(self.ha)
                self.ha = a
                self.nbuckets += nb
                if self.verbose:
                    print 'extending lower %s->%s %d buckets' % (str(hold), str(self.lower), nb)

            if addval:
                if self.verbose:
                    print 'adding value %s' % (str(v))
                self.addval(v, val)

        else: # currently saving values - save for future use

            self.extends.append(v)
            if self.verbose:
                print 'Adding %s to extend list' % (str(v))
            if addval:
                self.saved.append(val)


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


    def getval(self, val):
        
        t = type(val)
        if t is TupleType or t is ListType:
            v = val[0]
            t = type(v)
        else:
            v = val
            
        if t is FloatType:
                self.floatvals = 1

        return v


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


    def addval(self, v, val):
        
        
        l = self.lower
        u = self.upper
            
        if l < v <= u: # in range - add to histogram
            n = int((v - self.lower)/self.bucketsz)
            if self.lower + n*self.bucketsz == v:
                n -= 1
            #print v, n
            self.ha[n] += 1
            self.N += 1

            #
            # To maintain best precision in calculating variance and mean these
            # are incrementally calculated as each sample is added, rather than
            # at termination from accumulated total and sum of squares
            #
            # Algorithm courtesy of:
            # Eric W. Weisstein. "Sample Variance Computation."
            # From MathWorld--A Wolfram Web Resource.
            # http://mathworld.wolfram.com/SampleVarianceComputation.html
            #
            if self.N == 1:
                self.u = float(v)
                self.s2 = 0.0
            else:
                N = self.N
                u = self.u
                # running mean
                self.u = u + ((v-u)/N)
                # running variance
                ss = self.u - u
                self.s2 = ((1-(1/float(N-1)))*self.s2) + (N*ss*ss)

            if self.min == None:
                self.min = self.max = v
            else:
                self.min = min(v, self.min)
                self.max = max(v, self.max)
                
        else: # out of range
            if self.rangeexcept:
                if v <= l:
                    self.nlre += 1
                    raise HistogramLowRangeError('Value %s <= lower bound %s' % (v, l))
                else:
                    self.nhre += 1
                    raise HistogramHighRangeError('Value %s > upper bound %s' % (v, u))
            if self.orange:
                if v <= l:
                    self.lows.append(val)
                else:
                    self.highs.append(val)
            else:
                if v <= l:
                    self.nlows += 1
                else:
                    self.nhighs += 1

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

    def saveval(self, v, val):
        

        l = self.lower
        if l != None and v <= l:
            if self.rangeexcept:
                self.nlre += 1
                raise HistogramLowRangeError('Value %s <= lower bound %s' % (v, l))
        
        u = self.upper
        if u != None and v > u:
            if self.rangeexcept:
                self.nhre += 1
                raise HistogramHighRangeError('Value %s > upper bound %s' % (v, u))

        self.saved.append(val)
            

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

    def add(self, val):

        self.nsamples += 1

        v = self.getval(val)

        if self.samplemin == None:
            self.samplemin = self.samplemax = v
        else:
            self.samplemin = min(v, self.samplemin)
            self.samplemax = max(v, self.samplemax)

        if self.nsamples == 1:
            self.sampleu = float(v)
            self.samples2 = 0.0
        else:
            N = self.nsamples
            u = self.sampleu
            # running mean
            self.sampleu = u + ((v-u)/N)
            # running variance
            ss = self.sampleu - u
            self.samples2 = ((1-(1/float(N-1)))*self.samples2) + (N*ss*ss)

        if self.ha:
            self.addval(v, val)
        else:
            self.saveval(v, val)

            if self.ntrigvals and len(self.saved) > self.ntrigvals:
                self.makearray()

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


    def results(self, printit=0, draw=0, file='', title='', comment='', zeros=1):

        def write(s):

            for f in files:
                f.write(s + '\n')

        def bktrange(top):

            if self.bucketsz == 1 and not self.floatvals:
                return '%s' % str(top)
            else:
                return '%s - %s' % (top-self.bucketsz, top)

        if self.nsamples == 0:
            raise HistogramError('No samples presented')
        
        if self.saved:
            self.makearray()

        files = []
        
        hist_vals = []

        if printit:
            files.append(sys.stdout)

        if file:
            try:
                f = open(file, 'w')
            except IOError, s:
                print 'Histo.py - ERROR opening results file:', s
                sys.exit(1)
            files.append(f)

        if self.floating:
            fs = '%f'
            fsw = '%10.3f'
        else:
            fs = '%d'
            fsw = '%10d'

        if self.orange:
            nlow = len(self.lows)
            nhigh = len(self.highs)
        else:
            nlow = self.nlows
            nhigh = self.nhighs

        if self.N:
            mean = self.u
            sd = sqrt(self.s2)
        else:
            mean = sd = None
            
        samplemean = self.sampleu
        samplesd = sqrt(self.samples2)

        if title:
            write('#' + title)
            write('\n')
        write('# Produced by histo.py')
        write('')
        if comment: