types.py

HADOOP 0.18.0安装源代码头文件

        range = reDash.split(value)
        if len(range) > 1:
            start = int(range[0])
            end = int(range[1])
        else:
            start = int(range[0])
            end = None   
            
        return (start, end)     

    def __verify_uri(self, type, value):
        valueInfo = self.__get_value_info()

        _norm = None
        try:
            uriComponents = urlparse.urlparse(value)
            if uriComponents[0] == '' or uriComponents[0] == 'file':
              # if scheme is '' or 'file'
              if not os.path.isfile(uriComponents[2]) and \
                                         not os.path.isdir(uriComponents[2]):
                  raise Exception("Invalid local URI")
              else:
                  self.__set_value_info(valueInfo, normalized=self.normalize(
                                                                  type,value))
            else:
              # other schemes
              # currently not checking anything. TODO
              self.__set_value_info(valueInfo, normalized=self.normalize(
                                                                   type,value))
        except:
            errorString = "%s is an invalid uri" % value
            self.__set_value_info(valueInfo, errorData=errorString)

        return valueInfo

    def __norm_uri(self, value):
       uriComponents = list(urlparse.urlparse(value))
       if uriComponents[0] == '':
          # if scheme is '''
          return self.__normalizedPath(uriComponents[2])
       elif uriComponents[0] == 'file':
          # if scheme is 'file'
          normalizedPath = self.__normalizedPath(uriComponents[2])
          return urlparse.urlunsplit(uriComponents[0:1] + [normalizedPath] + uriComponents[3:])

       # Not dealing with any other case right now
       return value

    def __verify_timestamp(self, type, value):
        valueInfo = self.__get_value_info()

        if check_timestamp(value):
            self.__set_value_info(valueInfo, normalized=self.normalize(type, 
                                                                       value))
        else:
            self.__set_value_info(valueInfo)

        return valueInfo

    def __verify_hostname(self, type, value):
        valueInfo = self.__get_value_info()

        try:
            socket.gethostbyname(value)
            self.__set_value_info(valueInfo, normalized=self.normalize(type, 
                                                                       value))
        except:
            errorString = "%s is invalid (domain lookup failed)" % value
            self.__set_value_info(valueInfo, errorData=errorString)

        return valueInfo

    def __verify_user_account(self, type, value):
        valueInfo = self.__get_value_info()

        try:
            pwd.getpwnam(value)
        except:
            errorString = "'%s' user account does not exist" % value
            self.__set_value_info(valueInfo, errorData=errorString)
        else:
            self.__set_value_info(valueInfo, normalized=self.normalize(type, 
                                                                       value))

        return valueInfo

    def __verify_user_group(self, type, value):
        valueInfo = self.__get_value_info()

        try:
            grp.getgrnam(value)
        except:
            errorString = "'%s' group does not exist" % value
            self.__set_value_info(valueInfo, errorData=errorString)
        else:
            self.__set_value_info(valueInfo, normalized=self.normalize(type, 
                                                                       value))

        return valueInfo

    def __verify_nothing(self, type, value):
        valueInfo = self.__get_value_info()

        self.__set_value_info(valueInfo, normalized=self.normalize(type, 
                                                                   value))

        return valueInfo

    #--------------------------------------------------------------------------

    def normalize(self, type, value):
        try:
          normFunc = getattr(self, "_typeValidator__norm_%s" % type)
          return normFunc(value)
        except AttributeError, A:
          # this exception should occur only when we don't have corresponding normalize function
          return value

    def verify(self, type, value, allowNone=False):
        """Verifies a value based on its type.

           type      - supported configValidator type
           value     - data to be validated
           allowNone - don't freak out if None or '' is supplied

           returns a valueInfo dictionary:

            valueInfo = { 'isValid' : 1, 'normalized' : 5, 'errorData' : 0 }

           where:

            isValid    - true or false (0/1)
            normalized - the normalized value
            errorData  - if invalid an error string

           supported types:

            see top level"""

        result = None
        if allowNone:
            if value == '' or value == None:
                result = self.__verify_nothing(None, None)
                result['normalized'] = None
            else:
                result = self.verifyFunctions[type](type, value)
        else:
            result = self.verifyFunctions[type](type, value)

        return result

    def is_valid_type(self, type):
        """Returns true if type is valid."""

        return types.has_key(type)

    def type_info(self, type):
        """Returns type info dictionary."""

        dbInfo = dbTypes[types[type]['db']]
        typeInfo = types[type].copy()
        typeInfo['db'] = dbInfo

        return typeInfo

    def add(self, name, type, value):
        """Adds a value and type by name to the configValidate object to be
           verified using validate().

           name  - name used to key values and access the results of the
                   validation
           type  - configValidator type
           value - data to be verified"""

        self.validateList.append({ 'name' : name,
                                   'type' : type,
                                   'value': value })

    def validate(self, allowNone=False):
        """Validates configValidate object populating validatedInfo with
           valueInfo dictionaries for each value added to the object."""

        for valItem in self.validateList:
            valueInfo = self.verify(valItem['type'], valItem['value'],
                allowNone)
            if valueInfo:
                valueInfo['name'] = valItem['name']
                self.validatedInfo.append(valueInfo)
            else:
                raise Exception("\nMissing a return value: valueInfo\n%s" % \
                    self.verifyFunctions[valItem['type']](valItem['value']))

    def __normalizedPath(self, value):    
        oldWd = os.getcwd()
        if self.__originalDir:
          os.chdir(self.__originalDir)
        normPath = os.path.realpath(value)
        os.chdir(oldWd)
        return normPath


class display:
    def __init__(self):
        self.displayFunctions = {}
        self.__build_dispaly_functions()

    def __build_dispaly_functions(self):
        functions = {}
        for function in dir(self):
            functions[function] = 1

        for type in types.keys():
            # kinda bad, need to find out how to know the name of the class
            #  I'm in.  But it works.
            functionName = "_cisplay__display_%s" % type
            if functions.has_key(functionName):
                self.displayFunctions[type] = getattr(self, functionName)
            else:
                if type == '':
                    self.displayFunctions[type] = self.__display_default
                else:
                    error = "Display function %s for type %s does not exist." \
                        % (functionName, type)
                    raise Exception(error)
                    sys.exit(1)

    def __display_default(self, value, style):
        return value

    def __display_generic_number(self, value):
        displayNumber = ''
        splitNum = string.split(str(value), sep='.')
        numList = list(str(splitNum[0]))
        numList.reverse()
        length = len(numList)
        counter = 0
        for char in numList:
            counter = counter + 1
            if counter % 3 or counter == length:
                displayNumber = "%s%s" % (char, displayNumber)
            else:
                displayNumber = ",%s%s" % (char, displayNumber)

        if len(splitNum) > 1:
            displayNumber = "%s.%s" % (displayNumber, splitNum[1])

        return displayNumber

    def __display_generic_mappable(self, map, value, style, plural=True):
        displayValue = ''
        length = len(str(value))
        if length > 3:
            for factorSet in map:
                displayValue = float(value) / factorSet['factor']
                if len(str(int(displayValue))) <= 3 or \
                    factorSet['factor'] == map[-1]['factor']:
                    displayValue = "%10.2f" % displayValue    
                    if displayValue[-1] == '0':
                        if displayValue > 1 and style != 'short' and plural:
                            displayValue = "%s %ss" % (displayValue[:-1], 
                                                      factorSet[style])
                        else:
                            displayValue = "%s %s" % (displayValue[:-1], 
                                                      factorSet[style])
                    else:
                        if displayValue > 1 and style != 'short' and plural:
                            displayValue = "%s %ss" % (displayValue, 
                                                      factorSet[style])
                        else:
                            displayValue = "%s %s" % (displayValue, 
                                                      factorSet[style])
                    break

        return displayValue

    def __display_directory(self, value, style):
        return self.__display_default(value, style)

    def __display_address(self, value, style):
        return self.__display_default(value, style)

    def __display_ip_address(self, value, style):
        return self.__display_default(value, style)

    def __display_net_address(self, value, style):
        return self.__display_default(value, style)

    def __display_bool(self, value, style):
        displayValue = value
        
        if not isinstance(displayValue, bool):
            if re.match("^false|0|f|no$", value, 2):
                displayValue=False
            elif re.match("^true|1|t|yes$", value, 2):
                displayValue=True

        return displayValue

    def __display_int(self, value, style):
        return self.__display_generic_number(value)

    def __display_float(self, value, style):
        return self.__display_generic_number(value)

    def __display_pos_int(self, value, style):
        return self.__display_generic_number(value)

    def __display_neg_int(self, value, style):
        return self.__display_generic_number(value)

    def __display_pos_num(self, value, style):
        return self.__display_generic_number(value)

    def __display_pos_float(self, value, style):
        return self.__display_generic_number(value)

    def __display_neg_float(self, value, style):
        return self.__display_generic_number(value)

    def __display_string(self, value, style):
        return self.__display_default(value, style)

    def __display_list(self, value, style):
        value = value.rstrip()
        return value.rstrip(',')

    def __display_keyval(self, value, style):
        value = value.rstrip()
        return value.rstrip(',')

    def __display_file(self, value, style):
        return self.__display_default(value, style)

    def __display_size(self, value, style):
        return self.__display_generic_mappable(sizeMap, value, style)

    def __display_freq(self, value, style):
        return self.__display_generic_mappable(freqMap, value, style, False)

    def __display_eaddress(self, value, style):
        return self.__display_default(value, style)

    def __display_tcp_port(self, value, style):
        return self.__display_default(value, style)

    def __display_http_version(self, value, style):
        return self.__display_default(value, style)

    def __display_range(self, value, style):
        return self.__display_default(value, style)

    def __display_hostname(self, value, style):
        return self.__display_default(value, style)

    def __display_user_account(self, value, style):
        return self.__display_default(value, style)

    def __display_user_group(self, value, style):
        return self.__display_default(value, style)

    def __display_timestamp(self, value, style):
        return self.__display_default(value, style)

    def display(self, type, value, style='short'):
        displayValue = value
        if value != None:
            displayValue = self.displayFunctions[type](value, style)

        return displayValue

typeValidatorInstance = typeValidator()

def is_valid_type(type):
    """Returns true if type is valid."""

    return typeValidatorInstance.is_valid_type(type)

def type_info(type):
    """Returns type info dictionary."""

    return typeValidatorInstance.type_info(type)

def verify(type, value, allowNone=False):
    """Returns a normalized valueInfo dictionary."""

    return typeValidatorInstance.verify(type, value, allowNone)

def __normalize(map, val, factor):
    normFactor = string.lower(factor)
    normVal = float(val)
    return int(normVal * map[normFactor])

def normalize_size(size, factor):
    """ Normalize a size to bytes.

        size   - number of B, KB, MB, GB, TB, or PB
        factor - size factor (case insensitive):
                 b | bytes - bytes
                 k | kb    - kilobytes
                 m | mb    - megabytes
                 g | gb    - gigabytes
                 t | tb    - terabytes
                 p | pb    - petabytes
    """

    return __normalize(sizeFactors, size, factor)

def normalize_freq(freq, factor):
    """ Normalize a frequency to hertz.

        freq   - number of Hz, Khz, Mhz, Ghz, Thz, or Phz
        factor - size factor (case insensitive):
                 Hz  - Hertz
                 Mhz - Megahertz
                 Ghz - Gigahertz
                 Thz - Terahertz
                 Phz - Petahertz
    """

    return __normalize(freqFactors, freq, factor)