C:/work/RevealedSystems/EyeSpy-RS/eyespy/src/objects/gui/displayer/entityDisplayer.py

Go to the documentation of this file.

# Copyright (C) 2008-2009  Mark Hanegraaff
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.



import time
from objects.logic.utils.timeUtil import timeUtil


## The entityDisplayer is a base class which knows how to set the drawing attributes for a given entity.
# Derived classes will specialize the task of setting these attributes.
# Specifically, for each drawn Endpoint, this class will determine what label to use
# how thick connecting lines should be, etc. 
class entityDisplayer():
    
    ## entityDisplayer constructor
    def __init__(self, dispConfigurator):        
        self.setDisplayConfigurator(dispConfigurator)

    ## Sets the display Configurator object.
    # @param dispConfigurator Configurator object used to determine how to set attributes.            
    def setDisplayConfigurator(self, dispConfigurator):
        self.dispConfig = dispConfigurator
        self.setScales()
    
    ## Sets the Scaling properties. I.e. scale transfer size to KB, MB or GB
    # This determines how quickly circles will grow, or how it will take for lines
    # to fade.
    def setScales(self):
        self.displayTransferScale = self.dispConfig.glb_getDisplayScale()
        self.displayFadeTime      = self.dispConfig.glb_getFadeTime()
        
        # no divide by 0 please
        if self.displayFadeTime <= 0:
           self.displayFadeTime = 1
    
    ## Determines the Alpha value (i.e. transparency) of a line connecting two Endpoints.
    # @param networkEntity networkEntity object (object representing an Endpoint)
    # @return Float representing Alpha value.
    def _getAlpha(self, networkEntity):
          timeNow = time.time()
          
          timDelta = (timeNow - networkEntity.lastUpdateTS)
          
          # if entities are never being hidden, then this value could go below 0
          if (self.displayFadeTime - timDelta) < 0: return 0.08
          
          alpha = (self.displayFadeTime - timDelta) / self.displayFadeTime
          #print "float(self.displayFadeTime:%2.3f - timDelta%2.3f) / self.displayFadeTime:%2.3f" % (self.displayFadeTime, timDelta, self.displayFadeTime)
          
          return alpha 
    
    ## Determines the Endpoint's line width given the amount of Bytes transferred.
    # @param totBytes Total Bytes transferred   
    def _getLineWidth(self, totBytes):
        
        #0-1 MB -- 0.4
        #1-3 MB -- 0.5
        #3-5 MB -- 1.2
        #>5MB   -- 1.6
        
        if totBytes >= 0 and totBytes < 1 * self.displayTransferScale:
            return 0.4
        elif totBytes >= 1 * self.displayTransferScale and totBytes < 3 * self.displayTransferScale:
            return 0.8
        elif totBytes >= 3 * self.displayTransferScale and totBytes < 5 * self.displayTransferScale:
            return 1.2
        else:
            return 1.6
                  
    ## Returns a Dictionary of attributes given a networkEntity object
    # @param networkEntity networkEntity object (object representing an Endpoint) 
    # @return Dictionary of attributes     
    def getAttributesFromEntity(self, networkEntity):
        
        displayAttributes = dict()
        timeNow = time.time()
        
        """
         figure out the alpha value for the line
         based on how idle the peer is
        """
        displayAttributes["lineAlpha"] = self._getAlpha(networkEntity)                
        
        displayAttributes["marker"] = "ro"
        
        # set the line style
        if networkEntity.exactLocation == True:
            displayAttributes["lineStyle"] = "-"
        else:
            displayAttributes["lineStyle"] = ":"
            
        # set the label
        displayAttributes["label"] = self.getEntLabelFromConfigValue(networkEntity, self.dispConfig.glb_getDisplayLabel())
        
        
        displayAttributes["lineWidth"] =  self._getLineWidth(networkEntity.totalBytes)
        
        if networkEntity.totalBytes >= 0 and networkEntity.totalBytes < 1 * self.displayTransferScale:            
            displayAttributes["markerSize"] = 4
        elif networkEntity.totalBytes >= 1 * self.displayTransferScale and networkEntity.totalBytes < 3 * self.displayTransferScale:
            displayAttributes["markerSize"] = 6
        elif networkEntity.totalBytes >= 3 * self.displayTransferScale and networkEntity.totalBytes < 5 * self.displayTransferScale:
            displayAttributes["markerSize"] = 8
        else:
            displayAttributes["markerSize"] = 10

        return displayAttributes
    
    ## Returns a Dictionary of attributes given a list of networkEntity objects
    # This is necessary because sometimes Endpoints can share the same geographical locations 
    # @param entityList list of networkEntity objects (object representing an Endpoint)
    # @return Dictionary of attributes.    
    def getAttributesFromList(self, entityList):
        
        displayAttributes = dict()
        totBytes = 0
        totAlpha = 0
        atleastOneExactLocation = False
        atleastOneApproxLocation = False
        
        for netEnt in entityList:
            totBytes += netEnt.totalBytes
            if netEnt.exactLocation == True:
                atleastOneExactLocation = True
            else:
                atleastOneApproxLocation = True
                
            totAlpha += self._getAlpha(netEnt)
            
        
                
        if atleastOneExactLocation == True and atleastOneApproxLocation == True:
            displayAttributes["lineStyle"] = "-."
        elif atleastOneExactLocation == True and atleastOneApproxLocation == False:
            displayAttributes["lineStyle"] = "-"
        else:
            displayAttributes["lineStyle"] = ":"
                
        
        displayAttributes["label"] = "(x%d)" % (len(entityList))
        displayAttributes["markerSize"] = 10
        displayAttributes["marker"] = "r+"
        displayAttributes["lineWidth"] =  self._getLineWidth(totBytes)
        
        
        
        # alpha blending is just the average of all activity
        displayAttributes["lineAlpha"] = totAlpha/float(len(entityList))

        
        return displayAttributes
    
    
    ## returns the actual label given the user friendly name in the
    # display settings dialog dropdown menu
    # @param ent networkEntity about to be displayed 
    # @param userFriendlyName The user friendly name displayed in the display settings dialog    
    # @return String representation of some some networkEntity attribute
    def getEntLabelFromConfigValue(self, ent, userFriendlyName):
        retValue = ""        
        if userFriendlyName.upper() == "PROCESS NAME" or userFriendlyName.upper() == "_DEFAULT_": 
            retValue = ent.processName
        elif userFriendlyName.upper() == "IP ADDRESS":
            retValue = ent.foreignIPAddress
        elif userFriendlyName.upper() == "SRC. PORT":
            retValue = str(ent.selfPort)
        elif userFriendlyName.upper() == "DEST. PORT":
            retValue = str(ent.foreignPort)
        elif userFriendlyName.upper() == "CONN. SINCE":
            retValue = timeUtil.formatDateTime(ent.since)
        elif userFriendlyName.upper() == "IDLE TIME":
            retValue = timeUtil.formatTimeDiff(time.time() - ent.lastUpdateTS)
        elif userFriendlyName.upper() == "KB TRANSFER":
            retValue = "%6.2f Kb" % (ent.totalBytes / 1000)
        elif userFriendlyName.upper() == "CITY":
            retValue = ent.foreignCity
        elif userFriendlyName.upper() == "ISP":
            retValue = ent.foreignISP
        elif userFriendlyName.upper() == "ORGANIZATION":
            retValue = ent.foreignOrganization
        else:
            retValue = "No Conversion"
        
        if retValue == None or retValue == "":
            retValue = "Unknown"
        
        return retValue
    

---