@Override protected Collection<ValidationResult> customValidate(final ValidationContext context) { final List<ValidationResult> results = new ArrayList<>(super.customValidate(context)); final String destination = context.getProperty(DESTINATION).getValue(); if (DESTINATION_CONTENT.equals(destination)) { int xpathCount = 0; for (final PropertyDescriptor desc : context.getProperties().keySet()) { if (desc.isDynamic()) { xpathCount++; } } if (xpathCount != 1) { results.add(new ValidationResult.Builder().subject("XPaths").valid(false) .explanation("Exactly one XPath must be set if using destination of " + DESTINATION_CONTENT).build()); } } 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(final ValidationContext context) { final List<ValidationResult> errors = new ArrayList<>(super.customValidate(context)); final String regexValue = context.getProperty(REGEX).evaluateAttributeExpressions().getValue(); final int numCapturingGroups = Pattern.compile(regexValue).matcher("").groupCount(); final int groupToMatch = context.getProperty(MATCHING_GROUP_FOR_LOOKUP_KEY).evaluateAttributeExpressions().asInteger(); if (groupToMatch > numCapturingGroups) { errors.add( new ValidationResult.Builder() .subject("Insufficient Matching Groups") .valid(false) .explanation("The specified matching group does not exist for the regular expression provided") .build()); } return errors; }
@Override protected Collection<ValidationResult> customValidate(final ValidationContext context) { final List<ValidationResult> results = new ArrayList<>(super.customValidate(context)); final String destination = context.getProperty(DESTINATION).getValue(); if (DESTINATION_CONTENT.equals(destination)) { int xQueryCount = 0; for (final PropertyDescriptor desc : context.getProperties().keySet()) { if (desc.isDynamic()) { xQueryCount++; } } if (xQueryCount != 1) { results.add(new ValidationResult.Builder().subject("XQueries").valid(false) .explanation("Exactly one XQuery must be set if using destination of " + DESTINATION_CONTENT).build()); } } return results; }
@Override protected Collection<ValidationResult> customValidate(ValidationContext validationContext) { final List<ValidationResult> errors = new ArrayList<>(super.customValidate(validationContext)); final Set<PropertyDescriptor> dynamicProperties = validationContext.getProperties().keySet().stream() .filter(prop -> prop.isDynamic()) .collect(Collectors.toSet()); if (dynamicProperties == null || dynamicProperties.size() < 1) { errors.add(new ValidationResult.Builder() .subject("User-Defined Properties") .valid(false) .explanation("At least one user-defined property must be specified.") .build()); } final Set<String> requiredKeys = validationContext.getProperty(LOOKUP_SERVICE).asControllerService(LookupService.class).getRequiredKeys(); if (requiredKeys == null || requiredKeys.size() != 1) { errors.add(new ValidationResult.Builder() .subject(LOOKUP_SERVICE.getDisplayName()) .valid(false) .explanation("LookupAttribute requires a key-value lookup service supporting exactly one required key.") .build()); } return errors; }
@Override protected Collection<ValidationResult> customValidate(ValidationContext validationContext) { try { sleep(validationContext.getProperty(CUSTOM_VALIDATE_SLEEP_TIME).asTimePeriod(TimeUnit.MILLISECONDS), validationContext.getProperty(IGNORE_INTERRUPTS).asBoolean()); } catch (InterruptedException e) { Thread.currentThread().interrupt(); return Collections.singleton(new ValidationResult.Builder() .valid(false) .subject("Validation") .explanation("Processor Interrupted while performing validation").build()); } return super.customValidate(validationContext); }
@Override protected Collection<ValidationResult> customValidate(final ValidationContext context) { final List<ValidationResult> errors = new ArrayList<>(super.customValidate(context)); final String to = context.getProperty(TO).getValue(); final String cc = context.getProperty(CC).getValue(); final String bcc = context.getProperty(BCC).getValue(); if (to == null && cc == null && bcc == null) { errors.add(new ValidationResult.Builder().subject("To, CC, BCC").valid(false).explanation("Must specify at least one To/CC/BCC address").build()); } return errors; }
@Override protected Collection<ValidationResult> customValidate(ValidationContext context) { final List<ValidationResult> results = new ArrayList<>(super.customValidate(context)); if (context.getProperty(MODE).getValue().equals(MODE_MULTIFILE.getValue())) { String path = context.getProperty(BASE_DIRECTORY).evaluateAttributeExpressions().getValue(); if (path == null) { results.add(new ValidationResult.Builder() .subject(BASE_DIRECTORY.getName()) .valid(false) .explanation("Base directory property cannot be empty in Multifile mode.") .build()); } else if (!new File(path).isDirectory()) { results.add(new ValidationResult.Builder() .subject(BASE_DIRECTORY.getName()) .valid(false) .explanation(path + " is not a directory.") .build()); } } 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 protected Collection<ValidationResult> customValidate(ValidationContext validationContext) { List<ValidationResult> results = new ArrayList<>(super.customValidate(validationContext)); PropertyValue cacheEntryIdentifier = validationContext.getProperty(PROP_CACHE_ENTRY_IDENTIFIER); boolean elPresent = false; try { elPresent = cacheEntryIdentifier.isExpressionLanguagePresent(); } catch (NullPointerException npe) { // Unfortunate workaround to a mock framework bug (NIFI-4590) } if (elPresent) { // This doesn't do a full job of validating against the requirement that Put Cache Value In Attribute must be set if multiple // Cache Entry Identifiers are supplied (if Expression Language is used). The user could conceivably have a comma-separated list of EL statements, // or a single EL statement with commas inside it but that evaluates to a single item. results.add(new ValidationResult.Builder().valid(true).explanation("Contains Expression Language").build()); } else { if (!validationContext.getProperty(FetchDistributedMapCache.PROP_PUT_CACHE_VALUE_IN_ATTRIBUTE).isSet()) { String identifierString = cacheEntryIdentifier.getValue(); if (identifierString.contains(",")) { results.add(new ValidationResult.Builder().valid(false) .explanation("Multiple Cache Entry Identifiers specified without Put Cache Value In Attribute set").build()); } } } return results; }
@Override protected Collection<ValidationResult> customValidate(ValidationContext validationContext) { final List<ValidationResult> results = new ArrayList<>(super.customValidate(validationContext)); final Long waitTimeoutMillis = validationContext.getProperty(WAIT_TIMEOUT).asTimePeriod(TimeUnit.MICROSECONDS); final Long inactiveTimeoutMillis = validationContext.getProperty(INACTIVE_TIMEOUT).asTimePeriod(TimeUnit.MICROSECONDS); if (waitTimeoutMillis >= inactiveTimeoutMillis) { results.add(new ValidationResult.Builder().input(validationContext.getProperty(INACTIVE_TIMEOUT).getValue()) .subject(INACTIVE_TIMEOUT.getDisplayName()) .explanation(String.format("%s should be longer than %s", INACTIVE_TIMEOUT.getDisplayName(), WAIT_TIMEOUT.getDisplayName())) .valid(false) .build()); } return results; }
@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 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 List<ValidationResult> customValidate(ValidationContext validationContext) { final List<ValidationResult> results = new ArrayList<>(super.customValidate(validationContext)); final String chosenQUERY_PARSER = validationContext.getProperty(QUERY_PARSER).getValue(); if (!chosenQUERY_PARSER.equals(NONE.getValue()) && !validationContext.getProperty(QUERY_PARSER_INPUT).isSet() ) { results.add(new ValidationResult.Builder().input("QUERY_PARSER_INPUT") .subject(QUERY_PARSER.getDisplayName()) .explanation("Split and Regex parsers require a valid Regular Expression") .valid(false) .build()); } if (chosenQUERY_PARSER.equals(NONE.getValue()) && validationContext.getProperty(QUERY_PARSER_INPUT).isSet()) { results.add(new ValidationResult.Builder().input("QUERY_PARSER") .subject(QUERY_PARSER_INPUT.getDisplayName()) .explanation("NONE parser does not support the use of Regular Expressions. " + "Please select another parser or delete the regular expression entered in this field.") .valid(false) .build()); } return results; }
@Override protected Collection<ValidationResult> customValidate(ValidationContext validationContext) { final List<ValidationResult> results = new ArrayList<>(super.customValidate(validationContext));
@Override protected Collection<ValidationResult> customValidate(ValidationContext validationContext) { Collection<ValidationResult> results = new ArrayList<>(super.customValidate(validationContext)); boolean dynamicProperty = false;
@Override protected Collection<ValidationResult> customValidate(final ValidationContext context) { final List<ValidationResult> validationResults = new ArrayList<>(super.customValidate(context)); final String methodValue = context.getProperty(ENCRYPTION_ALGORITHM).getValue(); final EncryptionMethod encryptionMethod = EncryptionMethod.valueOf(methodValue); final String algorithm = encryptionMethod.getAlgorithm(); final String password = context.getProperty(PASSWORD).getValue(); final KeyDerivationFunction kdf = KeyDerivationFunction.valueOf(context.getProperty(KEY_DERIVATION_FUNCTION).getValue()); final String keyHex = context.getProperty(RAW_KEY_HEX).getValue(); if (isPGPAlgorithm(algorithm)) { final boolean encrypt = context.getProperty(MODE).getValue().equalsIgnoreCase(ENCRYPT_MODE); final String publicKeyring = context.getProperty(PUBLIC_KEYRING).getValue(); final String publicUserId = context.getProperty(PUBLIC_KEY_USERID).getValue(); final String privateKeyring = context.getProperty(PRIVATE_KEYRING).getValue(); final String privateKeyringPassphrase = context.getProperty(PRIVATE_KEYRING_PASSPHRASE).evaluateAttributeExpressions().getValue(); validationResults.addAll(validatePGP(encryptionMethod, password, encrypt, publicKeyring, publicUserId, privateKeyring, privateKeyringPassphrase)); } else { // Not PGP if (encryptionMethod.isKeyedCipher()) { // Raw key validationResults.addAll(validateKeyed(encryptionMethod, kdf, keyHex)); } else { // PBE boolean allowWeakCrypto = context.getProperty(ALLOW_WEAK_CRYPTO).getValue().equalsIgnoreCase(WEAK_CRYPTO_ALLOWED_NAME); validationResults.addAll(validatePBE(encryptionMethod, kdf, password, allowWeakCrypto)); } } return validationResults; }
final List<ValidationResult> problems = new ArrayList<>(super.customValidate(validationContext));
@Override protected Collection<ValidationResult> customValidate(final ValidationContext validationContext) { final List<ValidationResult> problems = new ArrayList<>(super.customValidate(validationContext)); final boolean accessKeySet = validationContext.getProperty(ACCESS_KEY).isSet(); final boolean secretKeySet = validationContext.getProperty(SECRET_KEY).isSet(); if ((accessKeySet && !secretKeySet) || (secretKeySet && !accessKeySet)) { problems.add(new ValidationResult.Builder().input("Access Key").valid(false).explanation("If setting Secret Key or Access Key, must set both").build()); } final boolean credentialsFileSet = validationContext.getProperty(CREDENTIALS_FILE).isSet(); if ((secretKeySet || accessKeySet) && credentialsFileSet) { problems.add(new ValidationResult.Builder().input("Access Key").valid(false).explanation("Cannot set both Credentials File and Secret Key/Access Key").build()); } final boolean proxyHostSet = validationContext.getProperty(PROXY_HOST).isSet(); final boolean proxyPortSet = validationContext.getProperty(PROXY_HOST_PORT).isSet(); if ((proxyHostSet && !proxyPortSet) || (!proxyHostSet && proxyPortSet)) { problems.add(new ValidationResult.Builder().subject("Proxy Host and Port").valid(false).explanation("If Proxy Host or Proxy Port is set, both must be set").build()); } final boolean proxyUserSet = validationContext.getProperty(PROXY_USERNAME).isSet(); final boolean proxyPwdSet = validationContext.getProperty(PROXY_PASSWORD).isSet(); if ((proxyUserSet && !proxyPwdSet) || (!proxyUserSet && proxyPwdSet)) { problems.add(new ValidationResult.Builder().subject("Proxy User and Password").valid(false).explanation("If Proxy Username or Proxy Password is set, both must be set").build()); } if (proxyUserSet && !proxyHostSet) { problems.add(new ValidationResult.Builder().subject("Proxy").valid(false).explanation("If Proxy username is set, proxy host must be set").build()); } ProxyConfiguration.validateProxySpec(validationContext, problems, PROXY_SPECS); return problems; }