@Override public ValidationResult validate(String subject, String input, ValidationContext context) { if("true".equalsIgnoreCase(input) || "false".equalsIgnoreCase(input)){ return new ValidationResult.Builder().subject(subject).valid(true).build(); } else{ return StandardValidators.createAttributeExpressionLanguageValidator(AttributeExpression.ResultType.BOOLEAN, false) .validate(subject, input, context); } } };
@Override public ValidationResult validate(final String subject, final String value, final ValidationContext context) { final String[] filenames = value.split(","); for (final String filename : filenames) { final ValidationResult result = StandardValidators.FILE_EXISTS_VALIDATOR.validate(subject, filename.trim(), context); if (!result.isValid()) { return result; } } return new ValidationResult.Builder().subject(subject).input(value).valid(true).build(); } }
@Override public ValidationResult validate(final String subject, final String value, final ValidationContext context) { final String[] filenames = value.split(","); for (final String filename : filenames) { final ValidationResult result = StandardValidators.FILE_EXISTS_VALIDATOR.validate(subject, filename.trim(), context); if (!result.isValid()) { return result; } } return new ValidationResult.Builder().subject(subject).input(value).valid(true).build(); } }
@Override protected Collection<ValidationResult> additionalCustomValidation(ValidationContext context) { final Collection<ValidationResult> results = new ArrayList<>(); final String delimiterStrategy = context.getProperty(DELIMITER_STRATEGY).getValue(); if(DELIMITER_STRATEGY_FILENAME.equals(delimiterStrategy)) { final String headerValue = context.getProperty(HEADER).getValue(); if (headerValue != null) { results.add(StandardValidators.FILE_EXISTS_VALIDATOR.validate(HEADER.getName(), headerValue, context)); } final String footerValue = context.getProperty(FOOTER).getValue(); if (footerValue != null) { results.add(StandardValidators.FILE_EXISTS_VALIDATOR.validate(FOOTER.getName(), footerValue, context)); } final String demarcatorValue = context.getProperty(DEMARCATOR).getValue(); if (demarcatorValue != null) { results.add(StandardValidators.FILE_EXISTS_VALIDATOR.validate(DEMARCATOR.getName(), demarcatorValue, context)); } } return results; }
@Override protected Collection<ValidationResult> customValidate(ValidationContext validationContext) { final List<ValidationResult> results = new ArrayList<>(super.customValidate(validationContext)); Validator validator = new RecordPathValidator(); Map<PropertyDescriptor, String> processorProperties = validationContext.getProperties(); for (final Map.Entry<PropertyDescriptor, String> entry : processorProperties.entrySet()) { PropertyDescriptor property = entry.getKey(); if (property.isDynamic() && property.isExpressionLanguageSupported()) { String dynamicValue = validationContext.getProperty(property).getValue(); if(!validationContext.isExpressionLanguagePresent(dynamicValue)) { results.add(validator.validate(property.getDisplayName(), dynamicValue, validationContext)); } } } return results; }
@Override protected Collection<ValidationResult> customValidate(ValidationContext validationContext) { final List<ValidationResult> errors = new ArrayList<>(super.customValidate(validationContext)); switch (validationContext.getProperty(REPLACEMENT_STRATEGY).getValue()) { case literalReplaceValue: errors.add(StandardValidators.NON_EMPTY_VALIDATOR .validate(SEARCH_VALUE.getName(), validationContext.getProperty(SEARCH_VALUE).getValue(), validationContext)); break; case regexReplaceValue: errors.add(StandardValidators.createRegexValidator(0, Integer.MAX_VALUE, true) .validate(SEARCH_VALUE.getName(), validationContext.getProperty(SEARCH_VALUE).getValue(), validationContext)); break; case appendValue: case prependValue: case alwaysReplace: default: // nothing to check, search value is not used break; } return errors; }
@Override protected Collection<ValidationResult> customValidate(final ValidationContext context) { final List<ValidationResult> validationResults = new ArrayList<>(super.customValidate(context)); final Validator rateValidator; switch (context.getProperty(RATE_CONTROL_CRITERIA).getValue().toLowerCase()) { case DATA_RATE: rateValidator = StandardValidators.DATA_SIZE_VALIDATOR; break; case ATTRIBUTE_RATE: rateValidator = StandardValidators.POSITIVE_LONG_VALIDATOR; final String rateAttr = context.getProperty(RATE_CONTROL_ATTRIBUTE_NAME).getValue(); if (rateAttr == null) { validationResults.add(new ValidationResult.Builder() .subject(RATE_CONTROL_ATTRIBUTE_NAME.getName()) .explanation("<Rate Controlled Attribute> property must be set if using <Rate Control Criteria> of 'attribute value'") .build()); } break; case FLOWFILE_RATE: default: rateValidator = StandardValidators.POSITIVE_LONG_VALIDATOR; break; } final ValidationResult rateResult = rateValidator.validate("Maximum Rate", context.getProperty(MAX_RATE).getValue(), context); if (!rateResult.isValid()) { validationResults.add(rateResult); } return validationResults; }
@Override public ValidationResult validate(String subject, String input, ValidationContext context) { ValidationResult result = new ValidationResult.Builder() .subject(subject).valid(true).input(input).build(); List<String> args = ArgumentUtils.splitArgs(input, context.getProperty(ARG_DELIMITER).getValue().charAt(0)); for (String arg : args) { ValidationResult valResult = ATTRIBUTE_EXPRESSION_LANGUAGE_VALIDATOR.validate(subject, arg, context); if (!valResult.isValid()) { result = valResult; break; } } return result; } }).build();
@Override public ValidationResult validate(String subject, String input, ValidationContext context) { if (context.isExpressionLanguageSupported(subject) && context.isExpressionLanguagePresent(input)) { return new ValidationResult.Builder().subject(subject).input(input).explanation("Expression Language Present").valid(true).build(); } return StandardValidators.NON_EMPTY_VALIDATOR.validate(subject, input, context); } };
reason = " it appears to be represented as an IP address which is out of legal range '" + parts[0] + "'"; ValidationResult result = StandardValidators.PORT_VALIDATOR.validate(parts[1], parts[1], context); if (!result.isValid()) { validHostPortPairs = false;
@Override protected Collection<ValidationResult> customValidate(final ValidationContext validationContext) { final List<ValidationResult> problems = new ArrayList<>(super.customValidate(validationContext)); // If the capture group zero is not going to be included, each dynamic property must have at least one group final boolean includeCaptureGroupZero = validationContext.getProperty(INCLUDE_CAPTURE_GROUP_ZERO).getValue().equalsIgnoreCase("true"); getLogger().debug("Include capture group zero is " + includeCaptureGroupZero); if (!includeCaptureGroupZero) { final Validator oneGroupMinimumValidator = StandardValidators.createRegexValidator(1, 40, true); for (Map.Entry<PropertyDescriptor, String> prop : validationContext.getProperties().entrySet()) { PropertyDescriptor pd = prop.getKey(); if (pd.isDynamic()) { String value = validationContext.getProperty(pd).getValue(); getLogger().debug("Evaluating dynamic property " + pd.getDisplayName() + " (" + pd.getName() + ") with value " + value); ValidationResult result = oneGroupMinimumValidator.validate(pd.getDisplayName(), value, validationContext); getLogger().debug("Validation result: " + result.toString()); if (!result.isValid()) { problems.add(result); } } } } return problems; }
@Override public ValidationResult validate(String subject, String input, ValidationContext context) { if (context.isExpressionLanguageSupported(subject) && context.isExpressionLanguagePresent(input)) { return new ValidationResult.Builder().subject(subject).input(input).explanation("Expression Language Present").valid(true).build(); } return StandardValidators.NON_EMPTY_VALIDATOR.validate(subject, input, context); } }
@Override public ValidationResult validate(final String subject, final String input, final ValidationContext context) { final String[] splits = input.split(","); if (splits.length == 0) { return new ValidationResult.Builder() .subject(subject) .input(input) .valid(false) .explanation("At least one URL must be specified") .build(); } for (final String split : splits) { final String url = split.trim(); final ValidationResult result = StandardValidators.URL_VALIDATOR.validate(subject, url, context); if (result != null && !result.isValid()) { return result; } } return new ValidationResult.Builder().subject(subject).input(input).valid(true).build(); }
@Override public ValidationResult validate(String subject, String input, ValidationContext context) { // expression language if (context.isExpressionLanguageSupported(subject) && context.isExpressionLanguagePresent(input)) { return new ValidationResult.Builder().subject(subject).input(input).explanation("Expression Language Present").valid(true).build(); } // not empty ValidationResult nonEmptyValidatorResult = StandardValidators.NON_EMPTY_VALIDATOR.validate(subject, input, context); if (!nonEmptyValidatorResult.isValid()) { return nonEmptyValidatorResult; } // check format final List<String> hostnamePortList = Arrays.asList(input.split(",")); for (String hostnamePort : hostnamePortList) { String[] addresses = hostnamePort.split(":"); // Protect against invalid input like http://127.0.0.1:9300 (URL scheme should not be there) if (addresses.length != 2) { return new ValidationResult.Builder().subject(subject).input(input).explanation( "Must be in hostname:port form (no scheme such as http://").valid(false).build(); } // Validate the port String port = addresses[1].trim(); ValidationResult portValidatorResult = StandardValidators.PORT_VALIDATOR.validate(subject, port, context); if (!portValidatorResult.isValid()) { return portValidatorResult; } } return new ValidationResult.Builder().subject(subject).input(input).explanation("Valid cluster definition").valid(true).build(); } };
final String expression = condition.getExpression().trim(); reasons.add(StandardValidators.createAttributeExpressionLanguageValidator(AttributeExpression.ResultType.BOOLEAN, false) .validate(String.format("Condition for rule '%s'.", rule.getName()), expression, context)); } else { reasons.add(StandardValidators.createAttributeExpressionLanguageValidator(AttributeExpression.ResultType.STRING, true) .validate(String.format("Action for rule '%s'.", rule.getName()), action.getValue(), context));
ValidationResult validationResult = validator.validate(descriptor.getName(), propValue, validationContext); if (validationResult != null) { results.add(validationResult);
public static Validator createListValidator(boolean trimEntries, boolean excludeEmptyEntries, Validator validator) { return (subject, input, context) -> { if (context.isExpressionLanguageSupported(subject) && context.isExpressionLanguagePresent(input)) { return new ValidationResult.Builder().subject(subject).input(input).explanation("Expression Language Present").valid(true).build(); } try { if (input == null) { return new ValidationResult.Builder().subject(subject).input(null).explanation("List must have at least one non-empty element").valid(false).build(); } final String[] list = input.split(","); for (String item : list) { String itemToValidate = trimEntries ? item.trim() : item; if (!isEmpty(itemToValidate) || !excludeEmptyEntries) { ValidationResult result = validator.validate(subject, itemToValidate, context); if (!result.isValid()) { return result; } } } return new ValidationResult.Builder().subject(subject).input(input).explanation("Valid List").valid(true).build(); } catch (final Exception e) { return new ValidationResult.Builder().subject(subject).input(input).explanation("Not a valid list").valid(false).build(); } }; }
@Override public ValidationResult validate(String subject, String input, ValidationContext context) { if (context.isExpressionLanguageSupported(subject) && context.isExpressionLanguagePresent(input)) { final AttributeExpression.ResultType resultType = context.newExpressionLanguageCompiler().getResultType(input); if (!resultType.equals(AttributeExpression.ResultType.STRING)) { return new ValidationResult.Builder() .subject(subject) .input(input) .valid(false) .explanation("Expected property to to return type " + AttributeExpression.ResultType.STRING + " but expression returns type " + resultType) .build(); } return new ValidationResult.Builder() .subject(subject) .input(input) .valid(true) .explanation("Property returns type " + AttributeExpression.ResultType.STRING) .build(); } return DPV_RE_VALIDATOR.validate(subject, input, context); } };
@Override public ValidationResult validate(final String subject, final String input, final ValidationContext context) { if (context.isExpressionLanguageSupported(subject) && context.isExpressionLanguagePresent(input)) { return new ValidationResult.Builder().subject(subject).input(input).explanation("Expression Language Present").valid(true).build(); } final ValidationResult vr = DATA_SIZE_VALIDATOR.validate(subject, input, context); if (!vr.isValid()) { return vr; } final long dataSizeBytes = DataUnit.parseDataSize(input, DataUnit.B).longValue(); if (dataSizeBytes < minBytesInclusive) { return new ValidationResult.Builder().subject(subject).input(input).valid(false).explanation("Cannot be smaller than " + minBytesInclusive + " bytes").build(); } if (dataSizeBytes > maxBytesInclusive) { return new ValidationResult.Builder().subject(subject).input(input).valid(false).explanation("Cannot be larger than " + maxBytesInclusive + " bytes").build(); } return new ValidationResult.Builder().subject(subject).input(input).valid(true).build(); } };