@Override protected String getSSLProtocolForValidation(final ValidationContext validationContext) { return validationContext.getProperty(RESTRICTED_SSL_ALGORITHM).getValue(); } }
@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 protected Collection<ValidationResult> customValidate(ValidationContext validationContext) { Set<ValidationResult> results = new HashSet<>(); boolean strict = validationContext.getProperty(VALIDATE_FIELD_NAMES).asBoolean(); // Iterate over dynamic properties, validating the schemas, and adding results validationContext.getProperties().entrySet().stream().filter(entry -> entry.getKey().isDynamic()).forEach(entry -> { String subject = entry.getKey().getDisplayName(); String input = entry.getValue(); try { final Schema avroSchema = new Schema.Parser().setValidate(strict).parse(input); AvroTypeUtil.createSchema(avroSchema, input, SchemaIdentifier.EMPTY); } catch (final Exception e) { results.add(new ValidationResult.Builder() .input(input) .subject(subject) .valid(false) .explanation("Not a valid Avro Schema: " + e.getMessage()) .build()); } }); return results; }
protected Collection<ValidationResult> customValidate(ValidationContext validationContext) { // For backwards-compatibility, keep track of whether the table name and max-value column properties are dynamic (i.e. has expression language) isDynamicTableName = validationContext.isExpressionLanguagePresent(validationContext.getProperty(TABLE_NAME).getValue()); isDynamicMaxValues = validationContext.isExpressionLanguagePresent(validationContext.getProperty(MAX_VALUE_COLUMN_NAMES).getValue()); return super.customValidate(validationContext); }
@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 context) { PropertyValue schemaProp = context.getProperty(SCHEMA); String schema = schemaProp.getValue(); String subject = SCHEMA.getName(); if (context.isExpressionLanguageSupported(subject) && context.isExpressionLanguagePresent(schema)) { return Collections.singletonList(new ValidationResult.Builder().subject(subject).input(schema).explanation("Expression Language Present").valid(true).build()); } // If no Expression Language is present, try parsing the schema try { this.parseSchema(schema); } catch (Exception e) { final List<ValidationResult> problems = new ArrayList<>(1); problems.add(new ValidationResult.Builder().subject(subject) .input(schema) .valid(false) .explanation("Error while parsing the schema: " + e.getMessage()) .build()); return problems; } return super.customValidate(context); }
@Override public ValidationResult validate(final String subject, final String input, final ValidationContext context) { String evaluatedInput = input; if (context.isExpressionLanguageSupported(subject) && context.isExpressionLanguagePresent(input)) { try { PropertyValue propertyValue = context.newPropertyValue(input); evaluatedInput = (propertyValue == null) ? input : propertyValue.evaluateAttributeExpressions().getValue(); } catch (final Exception e) { return new ValidationResult.Builder().subject(subject).input(input).explanation("Not a valid expression").valid(false).build(); } } String reason = null; try { if (!Charset.isSupported(evaluatedInput)) { reason = "Character Set is not supported by this JVM."; } } catch (final IllegalArgumentException iae) { reason = "Character Set value is null or is not supported by this JVM."; } return new ValidationResult.Builder().subject(subject).input(evaluatedInput).explanation(reason).valid(reason == null).build(); } };
@Override public ValidationResult validate(final String subject, final String input, final ValidationContext context) { if (context.isExpressionLanguageSupported(subject) && context.isExpressionLanguagePresent(input)) { try { final String result = context.newExpressionLanguageCompiler().validateExpression(input, true); if (!isEmpty(result)) { return new ValidationResult.Builder().subject(subject).input(input).valid(false).explanation(result).build(); } } catch (final Exception e) { return new ValidationResult.Builder().subject(subject).input(input).valid(false).explanation(e.getMessage()).build(); } } return new ValidationResult.Builder().subject(subject).input(input).valid(true).build(); }
@Override public ValidationResult validate(String subject, String input, ValidationContext context) { // Allows special, escaped characters as input, which is then unescaped and converted to a single character. // Examples for special characters: \t (or \u0009), \f. input = unescapeString(input); return new ValidationResult.Builder() .subject(subject) .input(input) .explanation("Only non-null single characters are supported") .valid(input.length() == 1 && input.charAt(0) != 0 || context.isExpressionLanguagePresent(input)) .build(); } };
public CredentialsStrategy selectPrimaryStrategy(final ValidationContext validationContext) { final Map<PropertyDescriptor, String> properties = validationContext.getProperties(); return selectPrimaryStrategy(properties); }
@Override public ValidationResult validate(String subject, String uri, ValidationContext context) { Configuration conf = getConfiguration(context.getProperty(CONF_XML_FILES).evaluateAttributeExpressions().getValue()); String error = null; if(StringUtils.isBlank(uri)) { return new ValidationResult.Builder().subject(subject).input(uri).explanation("Schema cannot be null.").valid(false).build(); } final boolean elPresent = context.isExpressionLanguageSupported(subject) && context.isExpressionLanguagePresent(uri); if (!elPresent) { try { getSchema(uri, conf); } catch (SchemaNotFoundException e) { error = e.getMessage(); } } return new ValidationResult.Builder() .subject(subject) .input(uri) .explanation(error) .valid(error == null) .build(); } };
@Override protected Collection<ValidationResult> customValidate(final ValidationContext validationContext) { final boolean cache = validationContext.getProperty(CACHE_SCHEMA).asBoolean(); if (cache) { for (final PropertyDescriptor descriptor : validationContext.getProperties().keySet()) { if (descriptor.isDynamic() && validationContext.isExpressionLanguagePresent(validationContext.getProperty(descriptor).getValue())) { return Collections.singleton(new ValidationResult.Builder() .subject("Cache Schema") .input("true") .valid(false) .explanation("Cannot have 'Cache Schema' property set to true if any SQL statement makes use of the Expression Language") .build()); } } } return Collections.emptyList(); }
@Override public ValidationResult validate(final String subject, final String value, final ValidationContext context) { if (context.isExpressionLanguageSupported(subject) && context.isExpressionLanguagePresent(value)) { return new ValidationResult.Builder().subject(subject).input(value).explanation("Expression Language Present").valid(true).build(); } final String substituted; if (allowEL) { try { substituted = context.newPropertyValue(value).evaluateAttributeExpressions().getValue(); } catch (final Exception e) { return new ValidationResult.Builder().subject(subject).input(value).valid(false) .explanation("Not a valid Expression Language value: " + e.getMessage()).build(); } } else { substituted = value; } final File file = new File(substituted); final boolean valid = file.exists(); final String explanation = valid ? null : "File " + file + " does not exist"; return new ValidationResult.Builder().subject(subject).input(value).valid(valid).explanation(explanation).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(String subject, String input, ValidationContext context) { // Allows special, escaped characters as input, which is then unescaped and converted to a single character. // Examples for special characters: \t (or \u0009), \f. input = unescapeString(input); return new ValidationResult.Builder() .subject(subject) .input(input) .explanation("Only non-null single characters are supported") .valid((input.length() == 1 && input.charAt(0) != 0) || context.isExpressionLanguagePresent(input)) .build(); } };
public CredentialsStrategy selectPrimaryStrategy(final ValidationContext validationContext) { final Map<PropertyDescriptor, String> properties = validationContext.getProperties(); return selectPrimaryStrategy(properties); }
@Override protected Collection<ValidationResult> customValidate(ValidationContext validationContext) { Set<ValidationResult> results = new HashSet<>(); final String segmentGranularity = validationContext.getProperty(SEGMENT_GRANULARITY).getValue(); final String queryGranularity = validationContext.getProperty(QUERY_GRANULARITY).getValue(); // Verify that segment granularity is as least as large as query granularity if (TIME_ORDINALS.indexOf(segmentGranularity) < TIME_ORDINALS.indexOf(queryGranularity)) { results.add(new ValidationResult.Builder().valid(false).explanation( "Segment Granularity must be at least as large as Query Granularity").build()); } return results; }
@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 protected Collection<ValidationResult> customValidate(final ValidationContext validationContext) { final List<ValidationResult> results = new ArrayList<>(); if (validationContext.getProperty(TRANSLATE_CONTENT).asBoolean().equals(Boolean.FALSE)) { boolean foundDynamic = false; for (final PropertyDescriptor descriptor : validationContext.getProperties().keySet()) { if (descriptor.isDynamic()) { foundDynamic = true; break; } } if (!foundDynamic) { results.add(new ValidationResult.Builder().subject("Text to translate").input("<none>").valid(false) .explanation("Must either set 'Translate Content' to true or add at least one user-defined property").build()); } } return results; }
@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(); } try { final String evaluatedInput = context.newPropertyValue(input).evaluateAttributeExpressions().getValue(); new URL(evaluatedInput); return new ValidationResult.Builder().subject(subject).input(input).explanation("Valid URL").valid(true).build(); } catch (final Exception e) { return new ValidationResult.Builder().subject(subject).input(input).explanation("Not a valid URL").valid(false).build(); } } };