types.py

HADOOP 0.18.0安装源代码头文件

                               'normalized' : /var/data/new,
                               'errorData'  : 0                        } ]"""

        if attrname   == "validateList":
            return self.validateList   # list of items to be validated
        elif attrname == "validatedInfo":
            return self.validatedInfo  # list of validation results
        else: raise AttributeError, attrname

    def __build_verify_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 = "_typeValidator__verify_%s" % type
            if functions.has_key(functionName):
                self.verifyFunctions[type] = getattr(self, functionName)
            else:
                if type == '':
                    self.verifyFunctions[type] = self.__verify_nothing
                else:
                    error = "Verify function %s for type %s does not exist." \
                        % (functionName, type)
                    raise Exception(error)
                    sys.exit(1)

    def __get_value_info(self):
        valueInfo = { 'isValid' : 0, 'normalized' : 0, 'errorData' : 0 }

        return valueInfo

    def __set_value_info(self, valueInfo, **valueData):
        try:
            valueInfo['normalized'] = valueData['normalized']
            valueInfo['isValid'] = 1
        except KeyError:
            valueInfo['isValid'] = 0
            try:
                valueInfo['errorData'] = valueData['errorData']
            except:
                pass

    # start of 'private' verification methods, each one should correspond to a
    #   type string (see self.verify_config())
    def __verify_directory(self, type, value):
        valueInfo = self.__get_value_info()

        if os.path.isdir(value):
            self.__set_value_info(valueInfo, normalized=self.normalize(type, 
                                                                       value))
        else:
            self.__set_value_info(valueInfo)

        return valueInfo
      
    def __norm_directory(self, value):
        return self.__normalizedPath(value)

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

        try:
            socket = tcpSocket(value)
            if socket.verify():
                self.__set_value_info(valueInfo, normalized=self.normalize(type, 
                                                                       value))
            else:
                self.__set_value_info(valueInfo)
        except:
            self.__set_value_info(valueInfo)

        return valueInfo
      
    def __norm_address(self, value):
        return value.split(':')

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

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

        return valueInfo

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

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

        return valueInfo

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

        value = str(value)
        if re.match("^false|0|f|no$", value, 2):
            self.__set_value_info(valueInfo, normalized=False)
        elif re.match("^true|1|t|yes$", value, 2):
            self.__set_value_info(valueInfo, normalized=True)
        else:
            self.__set_value_info(valueInfo)

        return valueInfo
      
    def __norm_bool(self, value):
        value = str(value)
        norm = ""
        if re.match("^false|0|f|no$", value, 2):
            norm = False
        elif re.match("^true|1|t|yes$", value, 2):
            norm = True
        else:
            raise Exception("invalid bool specified: %s" % value)
            
        return norm

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

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

        return valueInfo
      
    def __norm_int(self, value):
        return int(value)

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

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

        return valueInfo
      
    def __norm_float(self, value):
        return float(value)

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

        try:
            value = self.normalize(type, value)
        except:
            self.__set_value_info(valueInfo)
        else:
            self.__set_value_info(valueInfo, normalized=value)

        return valueInfo
      
    def __norm_pos_int(self, value):
        value = int(value)
        if value < 0:
            raise Exception("value is not positive: %s" % value)
        
        return value

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

        try:
            value = self.normalize(type, value)
        except:
            self.__set_value_info(valueInfo)
        else:
            self.__set_value_info(valueInfo, normalized=value)

        return valueInfo
      
    def __norm_neg_int(self, type, value):
        value = int(value)
        if value > 0:
            raise Exception("value is not negative: %s" % value)
        
        return value        

    def __verify_freq(self, type, value):
        return self.__verify_pos_int(type, value)

    def __norm_freq(self, value):
        return self.__norm_pos_int(value)

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

        try:
            value = self.normalize(type, value)
        except:
            self.__set_value_info(valueInfo)
        else:
            self.__set_value_info(valueInfo, normalized=value)

        return valueInfo

    def __norm_pos_float(self, value):
        value = float(value)
        if value < 0:
            raise Exception("value is not positive: %s" % value)
        
        return value

    def __verify_pos_num(self, type, value):
        return self.__verify_pos_float(value)
      
    def __norm_pos_num(self, value):
        return self.__norm_pos_float(value)

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

        try:
            value = self.normalize(type, value)
        except:
            self.__set_value_info(valueInfo)
        else:
            self.__set_value_info(valueInfo, normalized=value)

        return valueInfo

    def __norm_neg_float(self, value):
        value = float(value)
        if value >= 0:
            raise Exception("value is not negative: %s" % value)
        
        return value

    def __verify_string(self, type, value):
        valueInfo = self.__get_value_info()
        self.__set_value_info(valueInfo, normalized=self.normalize(type, 
                                                                   value))
        
        return valueInfo
      
    def __norm_string(self, value):
        return str(value)

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

        if reKeyVal.search(value):
          try:
            self.__set_value_info(valueInfo, normalized=self.normalize(type, 
                                value))
          except:
            self.__set_value_info(valueInfo, errorData = \
              "invalid list of key-value pairs : [ %s ]" % value)
        else:
            msg = "No key value pairs found?"
            self.__set_value_info(valueInfo, errorData=msg)

        return valueInfo
      
    def __norm_keyval(self, value):
        list = self.__norm_list(value)
        keyValue = {}
        for item in list:
            (key, value) = reKeyVal.split(item)
            #if not keyValue.has_key(key):
            #    keyValue[key] = []
            #keyValue[key].append(value)
            keyValue[key] = value
        return keyValue     

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

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

        return valueInfo
      
    def __norm_list(self, value):
        norm = []
        if reList.search(value):
            norm = reList.split(value)
        else:
            norm = [value,]
            
        return norm

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

        if os.path.isfile(value):
            self.__set_value_info(valueInfo, normalized=self.normalize(type,
                                                                       value))
        else:
            self.__set_value_info(valueInfo)

        return valueInfo
      
    def __norm_file(self, value):
        return self.__normalizedPath(value)

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

        value = str(value)
        if reSizeFormat.match(value):
            numberPart = int(reSizeFormat.sub("\g<1>", value))
            factorPart = reSizeFormat.sub("\g<2>", value)
            try:
                normalized = normalize_size(numberPart, factorPart)
                self.__set_value_info(valueInfo,
                    normalized=normalized)
            except:
                self.__set_value_info(valueInfo)
        else:
            try:
                value = int(value)
            except:
                self.__set_value_info(valueInfo)
            else:
                if value >= 0:
                    self.__set_value_info(valueInfo, normalized=value)
                else:
                    self.__set_value_info(valueInfo)

        return valueInfo

    def __norm_size(self, file):
        norm = None
        if reSizeFormat.match(value):
            numberPart = int(reSizeFormat.sub("\g<1>", value))
            factorPart = reSizeFormat.sub("\g<2>", value)
            norm = normalize_size(numberPart, factorPart)            
        else:
            norm = int(value)
            
        return norm
        
        
    def __verify_eaddress(self, type, value):
        valueInfo = self.__get_value_info()

        emailList = reComma.split(value)

        for emailAddress in emailList:
            if reEmailAddress.match(emailAddress):
                emailParts = reEmailDelimit.split(emailAddress)
                try:
                    socket.gethostbyname(emailParts[1])
                    self.__set_value_info(valueInfo, normalized=self.normalize(
                                          type, value))
                except:
                    errorString = "%s is invalid (domain lookup failed)" % \
                        emailAddress
                    self.__set_value_info(valueInfo, errorData=errorString)
            else:
                errorString = "%s is invalid" % emailAddress
                self.__set_value_info(valueInfo, errorData=errorString)

        return valueInfo

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

        try:
            value = self.__norm_tcp_port(value)
        except:
            self.__set_value_info(valueInfo)
        else:
            if value in range(2, 65536):
                self.__set_value_info(valueInfo, normalized=value)
            else:
                self.__set_value_info(valueInfo)

        return valueInfo
      
    def __norm_tcp_port(self, value):
        return int(value)

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

        if value in ('1.0', '1.1'):
            self.__set_value_info(valueInfo, normalized=float(value))
        else:
            self.__set_value_info(valueInfo)

        return valueInfo

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

        range = reDash.split(value)

        try:
            if len(range) > 1:
                start = int(range[0])
                end = int(range[1])
            else:
                start = int(range[0])
                end = None
        except:
            self.__set_value_info(valueInfo)
        else:
            if end:
                if end - start != 0:
                    self.__set_value_info(valueInfo, normalized=(start, end))
                else:
                    self.__set_value_info(valueInfo)
            else:
                self.__set_value_info(valueInfo, normalized=(start,))

        return valueInfo
      
    def __norm_range(self, value):