http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardAttributeExpression.java ---------------------------------------------------------------------- diff --git a/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardAttributeExpression.java b/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardAttributeExpression.java index 1e18953..a7ed184 100644 --- a/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardAttributeExpression.java +++ b/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardAttributeExpression.java @@ -21,13 +21,17 @@ import org.apache.nifi.expression.AttributeValueDecorator; import org.apache.nifi.flowfile.FlowFile; import org.apache.nifi.processor.exception.ProcessException; import org.apache.nifi.registry.VariableRegistry; -import org.apache.nifi.registry.VariableRegistryUtils; public class StandardAttributeExpression implements AttributeExpression { private final Query query; private final VariableRegistry variableRegistry; + public StandardAttributeExpression(final Query query) { + this.query = query; + this.variableRegistry = null; + } + public StandardAttributeExpression(final Query query, final VariableRegistry variableRegistry) { this.query = query; this.variableRegistry = variableRegistry; @@ -40,7 +44,7 @@ public class StandardAttributeExpression implements AttributeExpression { @Override public String evaluate() throws ProcessException { - return evaluate((AttributeValueDecorator) null); + return evaluate(null, null); } @Override @@ -55,8 +59,8 @@ public class StandardAttributeExpression implements AttributeExpression { @Override public String evaluate(final FlowFile flowFile, final AttributeValueDecorator decorator) throws ProcessException { - VariableRegistry flowFileRegistry = VariableRegistryUtils.createFlowVariableRegistry(variableRegistry,flowFile,null); - final Object evaluationResult = query.evaluate(flowFileRegistry).getValue(); + final ValueLookup lookup = new ValueLookup(variableRegistry, flowFile); + final Object evaluationResult = query.evaluate(lookup).getValue(); if (evaluationResult == null) { return ""; }
http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardExpressionLanguageCompiler.java ---------------------------------------------------------------------- diff --git a/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardExpressionLanguageCompiler.java b/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardExpressionLanguageCompiler.java index e85853f..01a4eb9 100644 --- a/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardExpressionLanguageCompiler.java +++ b/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardExpressionLanguageCompiler.java @@ -26,6 +26,10 @@ public class StandardExpressionLanguageCompiler implements ExpressionLanguageCom private final VariableRegistry variableRegistry; + public StandardExpressionLanguageCompiler() { + this.variableRegistry = VariableRegistry.EMPTY_REGISTRY; + } + public StandardExpressionLanguageCompiler(final VariableRegistry variableRegistry) { this.variableRegistry = variableRegistry; } http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardPreparedQuery.java ---------------------------------------------------------------------- diff --git a/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardPreparedQuery.java b/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardPreparedQuery.java index 4ee3e02..7473b3b 100644 --- a/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardPreparedQuery.java +++ b/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardPreparedQuery.java @@ -25,7 +25,6 @@ import org.apache.nifi.expression.AttributeValueDecorator; import org.apache.nifi.processor.exception.ProcessException; import org.antlr.runtime.tree.Tree; -import org.apache.nifi.registry.VariableRegistry; public class StandardPreparedQuery implements PreparedQuery { @@ -39,14 +38,14 @@ public class StandardPreparedQuery implements PreparedQuery { @Override - public String evaluateExpressions(final VariableRegistry registry, final AttributeValueDecorator decorator) throws ProcessException { + public String evaluateExpressions(final Map<String, String> valueMap, final AttributeValueDecorator decorator) throws ProcessException { final StringBuilder sb = new StringBuilder(); for (final String val : queryStrings) { final Tree tree = trees.get(val); if (tree == null) { sb.append(val); } else { - final String evaluated = Query.evaluateExpression(tree, val, registry, decorator); + final String evaluated = Query.evaluateExpression(tree, val, valueMap, decorator); if (evaluated != null) { sb.append(evaluated); } http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardPropertyValue.java ---------------------------------------------------------------------- diff --git a/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardPropertyValue.java b/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardPropertyValue.java index 4044f7a..d70b2d8 100644 --- a/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardPropertyValue.java +++ b/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/StandardPropertyValue.java @@ -27,7 +27,6 @@ import org.apache.nifi.flowfile.FlowFile; import org.apache.nifi.processor.DataUnit; import org.apache.nifi.processor.exception.ProcessException; import org.apache.nifi.registry.VariableRegistry; -import org.apache.nifi.registry.VariableRegistryUtils; import org.apache.nifi.util.FormatUtils; public class StandardPropertyValue implements PropertyValue { @@ -37,21 +36,32 @@ public class StandardPropertyValue implements PropertyValue { private final PreparedQuery preparedQuery; private final VariableRegistry variableRegistry; + public StandardPropertyValue(final String rawValue, final ControllerServiceLookup serviceLookup) { + this(rawValue, serviceLookup, Query.prepare(rawValue), VariableRegistry.EMPTY_REGISTRY); + } + public StandardPropertyValue(final String rawValue, final ControllerServiceLookup serviceLookup, final VariableRegistry variableRegistry) { this(rawValue, serviceLookup, Query.prepare(rawValue), variableRegistry); } /** - * Constructs a new StandardPropertyValue with the given value & service lookup and indicates whether or not the rawValue contains any NiFi Expressions. If it is unknown whether or not the value - * contains any NiFi Expressions, the {@link #StandardPropertyValue(String, ControllerServiceLookup, VariableRegistry)} constructor should be used or <code>true</code> should be passed. - * However, if it is known that the value contains no NiFi Expression, that information should be provided so that calls to {@link #evaluateAttributeExpressions()} are much more efficient + * Constructs a new StandardPropertyValue with the given value & service + * lookup and indicates whether or not the rawValue contains any NiFi + * Expressions. If it is unknown whether or not the value contains any NiFi + * Expressions, the + * {@link #StandardPropertyValue(String, ControllerServiceLookup, VariableRegistry)} + * constructor should be used or <code>true</code> should be passed. + * However, if it is known that the value contains no NiFi Expression, that + * information should be provided so that calls to + * {@link #evaluateAttributeExpressions()} are much more efficient + * * @param rawValue value * @param serviceLookup lookup * @param preparedQuery query * @param variableRegistry variableRegistry */ public StandardPropertyValue(final String rawValue, final ControllerServiceLookup serviceLookup, final PreparedQuery preparedQuery, - final VariableRegistry variableRegistry) { + final VariableRegistry variableRegistry) { this.rawValue = rawValue; this.serviceLookup = serviceLookup; this.preparedQuery = preparedQuery; @@ -138,12 +148,10 @@ public class StandardPropertyValue implements PropertyValue { if (rawValue == null || preparedQuery == null) { return this; } - VariableRegistry registry = VariableRegistryUtils.createFlowVariableRegistry(variableRegistry,flowFile,additionalAttributes); - return new StandardPropertyValue(preparedQuery.evaluateExpressions(registry,decorator), serviceLookup,null,registry); + final ValueLookup lookup = new ValueLookup(variableRegistry, flowFile, additionalAttributes); + return new StandardPropertyValue(preparedQuery.evaluateExpressions(lookup, decorator), serviceLookup, null, variableRegistry); } - - @Override public String toString() { return rawValue; http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/ValueLookup.java ---------------------------------------------------------------------- diff --git a/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/ValueLookup.java b/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/ValueLookup.java new file mode 100644 index 0000000..44da5a3 --- /dev/null +++ b/nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/ValueLookup.java @@ -0,0 +1,184 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.nifi.attribute.expression.language; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import org.apache.nifi.flowfile.FlowFile; +import org.apache.nifi.registry.VariableDescriptor; +import org.apache.nifi.registry.VariableRegistry; + +/** + * A convenience class to encapsulate the logic of variable substitution + * based first on any additional variable maps, then flow file properties, + * then flow file attributes, and finally the provided variable registry. + */ +final class ValueLookup implements Map<String, String> { + + final List<Map<String, String>> maps = new ArrayList<>(); + final VariableRegistry registry; + + /** + * Constructs a ValueLookup where values are looked up first based any + * provided additional maps, then flowfile properties, then flowfile + * attributes, then based on the provided variable registry. The lookup is + * immutable and operations which attempt to alter state will throw + * UnsupportedOperationException + * + * @param registry the variable registry to lookup from; may be null + * @param flowFile the flowFile to pull attributes from; may be null + * @param additionalMaps the maps to pull values from; may be null or empty + */ + ValueLookup(final VariableRegistry registry, final FlowFile flowFile, final Map<String, String>... additionalMaps) { + for (final Map<String, String> map : additionalMaps) { + if (map != null && !map.isEmpty()) { + maps.add(map); + } + } + if (flowFile != null) { + maps.add(ValueLookup.extractFlowFileProperties(flowFile)); + maps.add(flowFile.getAttributes()); + } + + this.registry = registry == null ? VariableRegistry.EMPTY_REGISTRY : registry; + } + + static final Map<String, String> extractFlowFileProperties(final FlowFile flowFile) { + final Map<String, String> flowFileProps = new HashMap<>(); + flowFileProps.put("flowFileId", String.valueOf(flowFile.getId())); + flowFileProps.put("fileSize", String.valueOf(flowFile.getSize())); + flowFileProps.put("entryDate", String.valueOf(flowFile.getEntryDate())); + flowFileProps.put("lineageStartDate", String.valueOf(flowFile.getLineageStartDate())); + flowFileProps.put("lastQueueDate", String.valueOf(flowFile.getLastQueueDate())); + flowFileProps.put("queueDateIndex", String.valueOf(flowFile.getQueueDateIndex())); + return flowFileProps; + } + + @Override + public int size() { + return keySet().size(); + } + + @Override + public boolean isEmpty() { + for (final Map<String, String> map : maps) { + if (!map.isEmpty()) { + return false; + } + } + return registry.getVariableMap().isEmpty(); + } + + @Override + public boolean containsKey(Object key) { + if (key == null) { + return false; + } + if (maps.stream().anyMatch((map) -> (map.containsKey(key)))) { + return true; + } + return registry.getVariableKey(key.toString()) != null; + } + + @Override + public boolean containsValue(Object value) { + if (value == null) { + return false; + } + //check entrySet then iterate through values (otherwise might find a value that was hidden/overriden + final Collection<String> values = values(); + return values.contains(value.toString()); + } + + @Override + public String get(Object key) { + if (key == null) { + return null; + } + + for (final Map<String, String> map : maps) { + final String val = map.get(key.toString()); + if (val != null) { + return val; + } + } + return registry.getVariableValue(key.toString()); + } + + @Override + public String put(String key, String value) { + throw new UnsupportedOperationException(); + } + + @Override + public String remove(Object key) { + throw new UnsupportedOperationException(); + } + + @Override + public void putAll(Map<? extends String, ? extends String> m) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public Set<String> keySet() { + final Set<String> keySet = new HashSet<>(); + entrySet().stream().forEach((entry) -> { + keySet.add(entry.getKey()); + }); + return keySet; + } + + @Override + public Collection<String> values() { + final Set<String> values = new HashSet<>(); + entrySet().stream().forEach((entry) -> { + values.add(entry.getValue()); + }); + return values; + } + + @Override + public Set<Entry<String, String>> entrySet() { + final Map<String, String> newMap = new HashMap<>(); + //put variable registry entries first + for (final Map.Entry<VariableDescriptor, String> entry : registry.getVariableMap().entrySet()) { + newMap.put(entry.getKey().getName(), entry.getValue()); + } + //put attribute maps in reverse order + final List<Map<String,String>> listOfMaps = new ArrayList<>(maps); + Collections.reverse(listOfMaps); + for(final Map<String,String> map : listOfMaps){ + for(final Map.Entry<String, String> entry : map.entrySet()){ + newMap.put(entry.getKey(), entry.getValue()); + } + } + return newMap.entrySet(); + } + +} http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-commons/nifi-expression-language/src/test/groovy/org/apache/nifi/attribute/expression/language/QueryGroovyTest.groovy ---------------------------------------------------------------------- diff --git a/nifi-commons/nifi-expression-language/src/test/groovy/org/apache/nifi/attribute/expression/language/QueryGroovyTest.groovy b/nifi-commons/nifi-expression-language/src/test/groovy/org/apache/nifi/attribute/expression/language/QueryGroovyTest.groovy index 3a5f587..bdd704d 100644 --- a/nifi-commons/nifi-expression-language/src/test/groovy/org/apache/nifi/attribute/expression/language/QueryGroovyTest.groovy +++ b/nifi-commons/nifi-expression-language/src/test/groovy/org/apache/nifi/attribute/expression/language/QueryGroovyTest.groovy @@ -18,8 +18,6 @@ package org.apache.nifi.attribute.expression.language import org.apache.nifi.attribute.expression.language.evaluation.QueryResult import org.apache.nifi.expression.AttributeExpression -import org.apache.nifi.registry.VariableRegistry -import org.apache.nifi.registry.VariableRegistryFactory import org.junit.After import org.junit.Before import org.junit.BeforeClass @@ -59,7 +57,6 @@ public class QueryGroovyTest extends GroovyTestCase { final Map<String, String> attributes = [ single : ORIGINAL_VALUE, repeating: [ORIGINAL_VALUE].multiply(n).join(" ")] - final VariableRegistry variableRegistry = VariableRegistryFactory.getInstance(attributes) logger.info("Attributes: ${attributes}") final String REPLACEMENT_VALUE = "Goodbye Planet" @@ -78,10 +75,10 @@ public class QueryGroovyTest extends GroovyTestCase { Query replaceRepeatingQuery = Query.compile(REPLACE_REPEATING_EXPRESSION) // Act - QueryResult<?> replaceSingleResult = replaceSingleQuery.evaluate(variableRegistry) + QueryResult<?> replaceSingleResult = replaceSingleQuery.evaluate(attributes) logger.info("Replace single result: ${replaceSingleResult.value}") - QueryResult<?> replaceRepeatingResult = replaceRepeatingQuery.evaluate(variableRegistry) + QueryResult<?> replaceRepeatingResult = replaceRepeatingQuery.evaluate(attributes) logger.info("Replace repeating result: ${replaceRepeatingResult.value}") // Assert @@ -100,7 +97,6 @@ public class QueryGroovyTest extends GroovyTestCase { final Map<String, String> attributes = [ single : ORIGINAL_VALUE, repeating: [ORIGINAL_VALUE].multiply(n).join(" ")] - final VariableRegistry variableRegistry = VariableRegistryFactory.getInstance(attributes) logger.info("Attributes: ${attributes}") final String REPLACEMENT_VALUE = "Goodbye Planet" @@ -119,10 +115,10 @@ public class QueryGroovyTest extends GroovyTestCase { Query replaceRepeatingQuery = Query.compile(REPLACE_REPEATING_EXPRESSION) // Act - QueryResult<?> replaceSingleResult = replaceSingleQuery.evaluate(variableRegistry) + QueryResult<?> replaceSingleResult = replaceSingleQuery.evaluate(attributes) logger.info("Replace single result: ${replaceSingleResult.value}") - QueryResult<?> replaceRepeatingResult = replaceRepeatingQuery.evaluate(variableRegistry) + QueryResult<?> replaceRepeatingResult = replaceRepeatingQuery.evaluate(attributes) logger.info("Replace repeating result: ${replaceRepeatingResult.value}") // Assert @@ -141,7 +137,6 @@ public class QueryGroovyTest extends GroovyTestCase { final Map<String, String> attributes = [ single : ORIGINAL_VALUE, repeating: [ORIGINAL_VALUE].multiply(n).join(" ")] - final VariableRegistry variableRegistry = VariableRegistryFactory.getInstance(attributes) logger.info("Attributes: ${attributes}") final String REPLACEMENT_VALUE = "Goodbye Planet" @@ -160,10 +155,10 @@ public class QueryGroovyTest extends GroovyTestCase { Query replaceRepeatingQuery = Query.compile(REPLACE_REPEATING_EXPRESSION) // Act - QueryResult<?> replaceSingleResult = replaceSingleQuery.evaluate(variableRegistry) + QueryResult<?> replaceSingleResult = replaceSingleQuery.evaluate(attributes) logger.info("Replace single result: ${replaceSingleResult.value}") - QueryResult<?> replaceRepeatingResult = replaceRepeatingQuery.evaluate(variableRegistry) + QueryResult<?> replaceRepeatingResult = replaceRepeatingQuery.evaluate(attributes) logger.info("Replace repeating result: ${replaceRepeatingResult.value}") // Assert http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-commons/nifi-expression-language/src/test/java/org/apache/nifi/attribute/expression/language/TestQuery.java ---------------------------------------------------------------------- diff --git a/nifi-commons/nifi-expression-language/src/test/java/org/apache/nifi/attribute/expression/language/TestQuery.java b/nifi-commons/nifi-expression-language/src/test/java/org/apache/nifi/attribute/expression/language/TestQuery.java index 2b3b5fe..fd09560 100644 --- a/nifi-commons/nifi-expression-language/src/test/java/org/apache/nifi/attribute/expression/language/TestQuery.java +++ b/nifi-commons/nifi-expression-language/src/test/java/org/apache/nifi/attribute/expression/language/TestQuery.java @@ -35,7 +35,6 @@ import java.util.HashSet; import java.util.List; import java.util.Locale; import java.util.Map; -import java.util.Properties; import org.apache.nifi.attribute.expression.language.Query.Range; import org.apache.nifi.attribute.expression.language.evaluation.QueryResult; @@ -46,8 +45,6 @@ import org.apache.nifi.flowfile.FlowFile; import org.antlr.runtime.tree.Tree; import org.apache.nifi.registry.VariableRegistry; -import org.apache.nifi.registry.VariableRegistryFactory; -import org.apache.nifi.registry.VariableRegistryUtils; import org.junit.Assert; import org.junit.Ignore; @@ -57,7 +54,6 @@ import org.mockito.Mockito; public class TestQuery { - @Test public void testCompilation() { assertInvalid("${attr:uuid()}"); @@ -106,9 +102,9 @@ public class TestQuery { Query.validateExpression("$${attr}", true); Query.validateExpression("${filename:startsWith('T8MTXBC')\n" - + ":or( ${filename:startsWith('C4QXABC')} )\n" - + ":or( ${filename:startsWith('U6CXEBC')} )" - + ":or( ${filename:startsWith('KYM3ABC')} )}", false); + + ":or( ${filename:startsWith('C4QXABC')} )\n" + + ":or( ${filename:startsWith('U6CXEBC')} )" + + ":or( ${filename:startsWith('KYM3ABC')} )}", false); } @Test @@ -121,7 +117,7 @@ public class TestQuery { final Map<String, String> attributes = new HashMap<>(); attributes.put("x", "x"); attributes.put("y", "x"); - final String result = Query.evaluateExpressions(expression,VariableRegistryFactory.getInstance(attributes), null); + final String result = Query.evaluateExpressions(expression, attributes, null); assertEquals("true", result); Query.validateExpression(expression, false); @@ -181,14 +177,13 @@ public class TestQuery { public void testWithTicksOutside() { final Map<String, String> attributes = new HashMap<>(); attributes.put("attr", "My Value"); - VariableRegistry registry = VariableRegistryFactory.getInstance(attributes); assertEquals(1, Query.extractExpressionRanges("\"${attr}").size()); assertEquals(1, Query.extractExpressionRanges("'${attr}").size()); assertEquals(1, Query.extractExpressionRanges("'${attr}'").size()); assertEquals(1, Query.extractExpressionRanges("${attr}").size()); - assertEquals("'My Value'", Query.evaluateExpressions("'${attr}'", registry, null)); - assertEquals("'My Value", Query.evaluateExpressions("'${attr}", registry, null)); + assertEquals("'My Value'", Query.evaluateExpressions("'${attr}'", attributes, null)); + assertEquals("'My Value", Query.evaluateExpressions("'${attr}", attributes, null)); } @Test @@ -198,7 +193,7 @@ public class TestQuery { final Map<String, String> attributes = new HashMap<>(); attributes.put("dateTime", "2013/11/18 10:22:27.678"); - final QueryResult<?> result = query.evaluate(VariableRegistryFactory.getInstance(attributes)); + final QueryResult<?> result = query.evaluate(attributes); assertEquals(ResultType.NUMBER, result.getResultType()); assertEquals(1384788147678L, result.getValue()); } @@ -227,7 +222,7 @@ public class TestQuery { final Date roundedToNearestSecond = new Date(date.getTime() - millis); final String formatted = sdf.format(roundedToNearestSecond); - final QueryResult<?> result = query.evaluate(VariableRegistryFactory.getInstance(attributes)); + final QueryResult<?> result = query.evaluate(attributes); assertEquals(ResultType.STRING, result.getResultType()); assertEquals(formatted, result.getValue()); } @@ -237,15 +232,14 @@ public class TestQuery { final Map<String, String> attributes = new HashMap<>(); attributes.put("x", "abc"); attributes.put("a", "abc"); - VariableRegistry registry = VariableRegistryFactory.getInstance(attributes); verifyEquals("${x:equals(${a})}", attributes, true); Query.validateExpression("${x:equals('${a}')}", false); - assertEquals("true", Query.evaluateExpressions("${x:equals('${a}')}", registry, null)); + assertEquals("true", Query.evaluateExpressions("${x:equals('${a}')}", attributes, null)); Query.validateExpression("${x:equals(\"${a}\")}", false); - assertEquals("true", Query.evaluateExpressions("${x:equals(\"${a}\")}", registry, null)); + assertEquals("true", Query.evaluateExpressions("${x:equals(\"${a}\")}", attributes, null)); } @Test @@ -278,18 +272,17 @@ public class TestQuery { @Test public void testEmbeddedExpressionsAndQuotesWithProperties() { - final Properties attributes = new Properties(); + final Map<String, String> attributes = new HashMap<>(); attributes.put("x", "abc"); attributes.put("a", "abc"); - VariableRegistry registry = VariableRegistryFactory.getPropertiesInstance(attributes); - verifyEquals("${x:equals(${a})}",registry,true); + verifyEquals("${x:equals(${a})}", attributes, true); Query.validateExpression("${x:equals('${a}')}", false); - assertEquals("true", Query.evaluateExpressions("${x:equals('${a}')}", registry, null)); + assertEquals("true", Query.evaluateExpressions("${x:equals('${a}')}", attributes, null)); Query.validateExpression("${x:equals(\"${a}\")}", false); - assertEquals("true", Query.evaluateExpressions("${x:equals(\"${a}\")}", registry, null)); + assertEquals("true", Query.evaluateExpressions("${x:equals(\"${a}\")}", attributes, null)); } @Test @@ -367,8 +360,8 @@ public class TestQuery { Mockito.when(mockFlowFile.getSize()).thenReturn(1L); Mockito.when(mockFlowFile.getLineageStartDate()).thenReturn(System.currentTimeMillis()); - final VariableRegistry variableRegistry = VariableRegistryUtils.createFlowVariableRegistry(VariableRegistryUtils.createSystemVariableRegistry(),mockFlowFile,null); - return Query.evaluateExpressions(queryString,variableRegistry); + final ValueLookup lookup = new ValueLookup(VariableRegistry.EMPTY_REGISTRY, mockFlowFile); + return Query.evaluateExpressions(queryString, lookup); } @Test @@ -524,7 +517,7 @@ public class TestQuery { verifyEquals("${x:toNumber():gt( ${y:toNumber():plus( ${z:toNumber()} )} )}", attributes, true); attributes.put("y", "88"); - assertEquals("true", Query.evaluateExpressions("${x:equals( '${y}' )}", VariableRegistryFactory.getInstance(attributes), null)); + assertEquals("true", Query.evaluateExpressions("${x:equals( '${y}' )}", attributes, null)); } @Test @@ -572,7 +565,7 @@ public class TestQuery { final String format = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"; final String query = "startDateTime=\"${date:toNumber():toDate():format(\"" + format + "\")}\""; - final String result = Query.evaluateExpressions(query, VariableRegistryFactory.getInstance(attributes), null); + final String result = Query.evaluateExpressions(query, attributes, null); final String expectedTime = new SimpleDateFormat(format, Locale.US).format(timestamp); assertEquals("startDateTime=\"" + expectedTime + "\"", result); @@ -641,7 +634,7 @@ public class TestQuery { final String query = "${ abc:equals('abc'):or( \n\t${xx:isNull()}\n) }"; assertEquals(ResultType.BOOLEAN, Query.getResultType(query)); Query.validateExpression(query, false); - assertEquals("true", Query.evaluateExpressions(query,VariableRegistryUtils.createSystemVariableRegistry())); + assertEquals("true", Query.evaluateExpressions(query, Collections.EMPTY_MAP)); } @Test @@ -657,23 +650,22 @@ public class TestQuery { public void testComments() { final Map<String, String> attributes = new HashMap<>(); attributes.put("abc", "xyz"); - VariableRegistry registry = VariableRegistryFactory.getInstance(attributes); final String expression - = "# hello, world\n" - + "${# ref attr\n" - + "\t" - + "abc" - + "\t" - + "#end ref attr\n" - + "}"; + = "# hello, world\n" + + "${# ref attr\n" + + "\t" + + "abc" + + "\t" + + "#end ref attr\n" + + "}"; Query query = Query.compile(expression); - QueryResult<?> result = query.evaluate(registry); + QueryResult<?> result = query.evaluate(attributes); assertEquals(ResultType.STRING, result.getResultType()); assertEquals("xyz", result.getValue()); query = Query.compile("${abc:append('# hello') #good-bye \n}"); - result = query.evaluate(registry); + result = query.evaluate(attributes); assertEquals(ResultType.STRING, result.getResultType()); assertEquals("xyz# hello", result.getValue()); } @@ -802,28 +794,19 @@ public class TestQuery { final Map<String, String> attributes = new HashMap<>(); attributes.put("entryDate", String.valueOf(now.getTimeInMillis())); - VariableRegistry registry = VariableRegistryFactory.getInstance(attributes); verifyEquals("${entryDate:toNumber():toDate():format('yyyy')}", attributes, String.valueOf(year)); attributes.clear(); attributes.put("month", "3"); attributes.put("day", "4"); attributes.put("year", "2013"); - assertEquals("63", Query.evaluateExpressions("${year:append('/'):append(${month}):append('/'):append(${day}):toDate('yyyy/MM/dd'):format('D')}", registry, null)); - assertEquals("63", Query.evaluateExpressions("${year:append('/'):append('${month}'):append('/'):append('${day}'):toDate('yyyy/MM/dd'):format('D')}", registry, null)); + assertEquals("63", Query.evaluateExpressions("${year:append('/'):append(${month}):append('/'):append(${day}):toDate('yyyy/MM/dd'):format('D')}", attributes, null)); + assertEquals("63", Query.evaluateExpressions("${year:append('/'):append('${month}'):append('/'):append('${day}'):toDate('yyyy/MM/dd'):format('D')}", attributes, null)); verifyEquals("${year:append('/'):append(${month}):append('/'):append(${day}):toDate('yyyy/MM/dd'):format('D')}", attributes, "63"); } @Test - public void testSystemProperty() { - System.setProperty("hello", "good-bye"); - VariableRegistry variableRegistry = VariableRegistryUtils.createSystemVariableRegistry(); - assertEquals("good-bye", Query.evaluateExpressions("${hello}",variableRegistry)); - assertEquals("good-bye", Query.compile("${hello}").evaluate(variableRegistry).getValue()); - } - - @Test public void testAnyAttribute() { final Map<String, String> attributes = new HashMap<>(); attributes.put("abc", "zzz"); @@ -860,15 +843,14 @@ public class TestQuery { final Map<String, String> attributes = new HashMap<>(); attributes.put("abc", "a,b,c"); attributes.put("xyz", "abc"); - VariableRegistry registry = VariableRegistryFactory.getInstance(attributes); final String query = "${anyDelineatedValue('${abc}', ','):equals('b')}"; assertEquals(ResultType.BOOLEAN, Query.getResultType(query)); - assertEquals("true", Query.evaluateExpressions(query, registry, null)); - assertEquals("true", Query.evaluateExpressions("${anyDelineatedValue('${abc}', ','):equals('a')}", registry, null)); - assertEquals("true", Query.evaluateExpressions("${anyDelineatedValue('${abc}', ','):equals('c')}", registry, null)); - assertEquals("false", Query.evaluateExpressions("${anyDelineatedValue('${abc}', ','):equals('d')}", registry, null)); + assertEquals("true", Query.evaluateExpressions(query, attributes, null)); + assertEquals("true", Query.evaluateExpressions("${anyDelineatedValue('${abc}', ','):equals('a')}", attributes, null)); + assertEquals("true", Query.evaluateExpressions("${anyDelineatedValue('${abc}', ','):equals('c')}", attributes, null)); + assertEquals("false", Query.evaluateExpressions("${anyDelineatedValue('${abc}', ','):equals('d')}", attributes, null)); verifyEquals("${anyDelineatedValue(${abc}, ','):equals('b')}", attributes, true); verifyEquals("${anyDelineatedValue(${abc}, ','):equals('a')}", attributes, true); @@ -882,15 +864,13 @@ public class TestQuery { attributes.put("abc", "a,b,c"); attributes.put("xyz", "abc"); - VariableRegistry registry = VariableRegistryFactory.getInstance(attributes); - final String query = "${allDelineatedValues('${abc}', ','):matches('[abc]')}"; assertEquals(ResultType.BOOLEAN, Query.getResultType(query)); - assertEquals("true", Query.evaluateExpressions(query, registry, null)); - assertEquals("true", Query.evaluateExpressions(query, registry, null)); - assertEquals("false", Query.evaluateExpressions("${allDelineatedValues('${abc}', ','):matches('[abd]')}",registry, null)); - assertEquals("false", Query.evaluateExpressions("${allDelineatedValues('${abc}', ','):equals('a'):not()}", registry, null)); + assertEquals("true", Query.evaluateExpressions(query, attributes, null)); + assertEquals("true", Query.evaluateExpressions(query, attributes, null)); + assertEquals("false", Query.evaluateExpressions("${allDelineatedValues('${abc}', ','):matches('[abd]')}", attributes, null)); + assertEquals("false", Query.evaluateExpressions("${allDelineatedValues('${abc}', ','):equals('a'):not()}", attributes, null)); verifyEquals("${allDelineatedValues(${abc}, ','):matches('[abc]')}", attributes, true); verifyEquals("${allDelineatedValues(${abc}, ','):matches('[abd]')}", attributes, false); @@ -956,13 +936,12 @@ public class TestQuery { attributes.put("xyz", "4132"); attributes.put("hello", "world!"); attributes.put("dotted", "abc.xyz"); - VariableRegistry registry = VariableRegistryFactory.getInstance(attributes); - final String evaluated = Query.evaluateExpressions("${abc:matches('1234${end}4321')}", registry, null); + final String evaluated = Query.evaluateExpressions("${abc:matches('1234${end}4321')}", attributes, null); assertEquals("true", evaluated); attributes.put("end", "888"); - final String secondEvaluation = Query.evaluateExpressions("${abc:matches('1234${end}4321')}", registry, null); + final String secondEvaluation = Query.evaluateExpressions("${abc:matches('1234${end}4321')}", attributes, null); assertEquals("false", secondEvaluation); verifyEquals("${dotted:matches('abc\\.xyz')}", attributes, true); @@ -977,13 +956,12 @@ public class TestQuery { attributes.put("hello", "world!"); attributes.put("dotted", "abc.xyz"); - final String evaluated = Query.evaluateExpressions("${abc:find('1234${end}4321')}", VariableRegistryFactory.getInstance(attributes), null); + final String evaluated = Query.evaluateExpressions("${abc:find('1234${end}4321')}", attributes, null); assertEquals("true", evaluated); attributes.put("end", "888"); - - final String secondEvaluation = Query.evaluateExpressions("${abc:find('${end}4321')}",VariableRegistryFactory.getInstance(attributes), null); + final String secondEvaluation = Query.evaluateExpressions("${abc:find('${end}4321')}", attributes, null); assertEquals("false", secondEvaluation); verifyEquals("${dotted:find('\\.')}", attributes, true); @@ -1105,16 +1083,22 @@ public class TestQuery { attributes.put("filename 3", "abcxy"); final String query - = "${" - + " 'non-existing':notNull():not():and(" + // true AND ( - " ${filename1:startsWith('y')" + // false - " :or(" + // or - " ${ filename1:startsWith('x'):and(false) }" + // false - " ):or(" + // or - " ${ filename2:endsWith('xxxx'):or( ${'filename 3':length():gt(1)} ) }" + // true ) - " )}" - + " )" - + "}"; + = "${" + + " 'non-existing':notNull():not():and(" + + // true AND ( + " ${filename1:startsWith('y')" + + // false + " :or(" + + // or + " ${ filename1:startsWith('x'):and(false) }" + + // false + " ):or(" + + // or + " ${ filename2:endsWith('xxxx'):or( ${'filename 3':length():gt(1)} ) }" + + // true ) + " )}" + + " )" + + "}"; System.out.println(query); verifyEquals(query, attributes, true); @@ -1164,7 +1148,7 @@ public class TestQuery { attributes.put("b", "x"); attributes.put("abcxcba", "hello"); - final String evaluated = Query.evaluateExpressions("${ 'abc${b}cba':substring(0, 1) }", VariableRegistryFactory.getInstance(attributes), null); + final String evaluated = Query.evaluateExpressions("${ 'abc${b}cba':substring(0, 1) }", attributes, null); assertEquals("h", evaluated); } @@ -1198,21 +1182,21 @@ public class TestQuery { final List<String> expressions = Query.extractExpressions(query); assertEquals(1, expressions.size()); assertEquals("${abc}", expressions.get(0)); - assertEquals("{ xyz }", Query.evaluateExpressions(query, VariableRegistryFactory.getInstance(attributes))); + assertEquals("{ xyz }", Query.evaluateExpressions(query, attributes)); } @Test public void testLiteralFunction() { - final Map<String, String> attrs = Collections.<String, String> emptyMap(); + final Map<String, String> attrs = Collections.<String, String>emptyMap(); verifyEquals("${literal(2):gt(1)}", attrs, true); verifyEquals("${literal('hello'):substring(0, 1):equals('h')}", attrs, true); } @Test public void testRandomFunction() { - final Map<String, String> attrs = Collections.<String, String> emptyMap(); + final Map<String, String> attrs = Collections.<String, String>emptyMap(); final Long negOne = Long.valueOf(-1L); - final HashSet<Long> results = new HashSet<Long>(100); + final HashSet<Long> results = new HashSet<>(100); for (int i = 0; i < results.size(); i++) { long result = (Long) getResult("${random()}", attrs).getValue(); assertThat("random", result, greaterThan(negOne)); @@ -1222,7 +1206,7 @@ public class TestQuery { QueryResult<?> getResult(String expr, Map<String, String> attrs) { final Query query = Query.compile(expr); - final QueryResult<?> result = query.evaluate(VariableRegistryFactory.getInstance(attrs)); + final QueryResult<?> result = query.evaluate(attrs); return result; } @@ -1331,17 +1315,11 @@ public class TestQuery { } private void verifyEquals(final String expression, final Map<String, String> attributes, final Object expectedResult) { - - VariableRegistry registry = VariableRegistryFactory.getInstance(attributes); - verifyEquals(expression,registry,expectedResult); - } - - private void verifyEquals(final String expression, final VariableRegistry registry, final Object expectedResult) { Query.validateExpression(expression, false); - assertEquals(String.valueOf(expectedResult), Query.evaluateExpressions(expression, registry, null)); + assertEquals(String.valueOf(expectedResult), Query.evaluateExpressions(expression, attributes, null)); final Query query = Query.compile(expression); - final QueryResult<?> result = query.evaluate(registry); + final QueryResult<?> result = query.evaluate(attributes); if (expectedResult instanceof Number) { assertEquals(ResultType.NUMBER, result.getResultType()); http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-commons/nifi-expression-language/src/test/java/org/apache/nifi/attribute/expression/language/TestStandardPreparedQuery.java ---------------------------------------------------------------------- diff --git a/nifi-commons/nifi-expression-language/src/test/java/org/apache/nifi/attribute/expression/language/TestStandardPreparedQuery.java b/nifi-commons/nifi-expression-language/src/test/java/org/apache/nifi/attribute/expression/language/TestStandardPreparedQuery.java index dbee665..5acba8d 100644 --- a/nifi-commons/nifi-expression-language/src/test/java/org/apache/nifi/attribute/expression/language/TestStandardPreparedQuery.java +++ b/nifi-commons/nifi-expression-language/src/test/java/org/apache/nifi/attribute/expression/language/TestStandardPreparedQuery.java @@ -22,7 +22,6 @@ import java.util.HashMap; import java.util.Map; import java.util.concurrent.TimeUnit; -import org.apache.nifi.registry.VariableRegistryFactory; import org.junit.Ignore; import org.junit.Test; @@ -54,7 +53,7 @@ public class TestStandardPreparedQuery { final StandardPreparedQuery prepared = (StandardPreparedQuery) Query.prepare("${xx}"); final long start = System.nanoTime(); for (int i = 0; i < 10000000; i++) { - assertEquals("world", prepared.evaluateExpressions(VariableRegistryFactory.getInstance(attrs), null)); + assertEquals("world", prepared.evaluateExpressions(attrs, null)); } final long nanos = System.nanoTime() - start; System.out.println(TimeUnit.NANOSECONDS.toMillis(nanos)); @@ -68,7 +67,7 @@ public class TestStandardPreparedQuery { final long start = System.nanoTime(); for (int i = 0; i < 10000000; i++) { - assertEquals("world", Query.evaluateExpressions("${xx}", VariableRegistryFactory.getInstance(attrs))); + assertEquals("world", Query.evaluateExpressions("${xx}", attrs)); } final long nanos = System.nanoTime() - start; System.out.println(TimeUnit.NANOSECONDS.toMillis(nanos)); @@ -86,7 +85,7 @@ public class TestStandardPreparedQuery { } private String evaluate(final String query, final Map<String, String> attrs) { - final String evaluated = ((StandardPreparedQuery) Query.prepare(query)).evaluateExpressions(VariableRegistryFactory.getInstance(attrs), null); + final String evaluated = ((StandardPreparedQuery) Query.prepare(query)).evaluateExpressions(attrs, null); return evaluated; } http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-commons/nifi-expression-language/src/test/java/org/apache/nifi/attribute/expression/language/TestValueLookup.java ---------------------------------------------------------------------- diff --git a/nifi-commons/nifi-expression-language/src/test/java/org/apache/nifi/attribute/expression/language/TestValueLookup.java b/nifi-commons/nifi-expression-language/src/test/java/org/apache/nifi/attribute/expression/language/TestValueLookup.java new file mode 100644 index 0000000..ec8ba66 --- /dev/null +++ b/nifi-commons/nifi-expression-language/src/test/java/org/apache/nifi/attribute/expression/language/TestValueLookup.java @@ -0,0 +1,150 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.nifi.attribute.expression.language; + +import java.util.HashMap; +import java.util.Map; +import org.apache.nifi.flowfile.FlowFile; +import org.apache.nifi.registry.VariableRegistry; +import org.junit.Test; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertEquals; + +/** + * + */ +public class TestValueLookup { + + @Test + public void testCreateCustomVariableRegistry() { + + final VariableRegistry variableRegistry = VariableRegistry.ENVIRONMENT_SYSTEM_REGISTRY; + final ValueLookup initialLookup = new ValueLookup(variableRegistry, null); + assertTrue(initialLookup.containsKey("PATH")); + assertFalse(initialLookup.containsKey("fake.property.3")); + assertFalse(initialLookup.containsKey("fake")); + + final Map<String, String> otherAttrs = new HashMap<>(); + otherAttrs.put("fake", "test"); + otherAttrs.put("fake.property.3", "test me out 3, test me out 4"); + final ValueLookup newLookup = new ValueLookup(variableRegistry, null, otherAttrs); + assertTrue(newLookup.containsKey("PATH")); + assertTrue(newLookup.containsKey("fake.property.3")); + assertEquals("test me out 3, test me out 4", newLookup.get("fake.property.3")); + assertEquals("test", newLookup.get("fake")); + assertFalse(newLookup.containsKey("filename")); + + final FlowFile fakeFile = createFlowFile(); + final ValueLookup ffLookup = new ValueLookup(variableRegistry, fakeFile, otherAttrs); + assertTrue(ffLookup.containsKey("filename")); + assertEquals("test", ffLookup.get("fake")); + assertEquals("1", ffLookup.get("flowFileId")); + assertEquals("50", ffLookup.get("fileSize")); + assertEquals("1000", ffLookup.get("entryDate")); + assertEquals("10000", ffLookup.get("lineageStartDate")); + assertEquals("fakefile.txt", ffLookup.get("filename")); + + final Map<String, String> overrides = new HashMap<>(); + overrides.put("fake", "the real deal"); + final ValueLookup overriddenLookup = new ValueLookup(variableRegistry, fakeFile, overrides, otherAttrs); + assertTrue(overriddenLookup.containsKey("filename")); + assertEquals("the real deal", overriddenLookup.get("fake")); + assertEquals("1", overriddenLookup.get("flowFileId")); + assertEquals("50", overriddenLookup.get("fileSize")); + assertEquals("1000", overriddenLookup.get("entryDate")); + assertEquals("10000", overriddenLookup.get("lineageStartDate")); + assertEquals("fakefile.txt", overriddenLookup.get("filename")); + assertEquals("original", overriddenLookup.get("override me")); + + final Map<String, String> newOverrides = new HashMap<>(); + newOverrides.put("fake", "the real deal"); + newOverrides.put("override me", "done you are now overridden"); + final ValueLookup newOverriddenLookup = new ValueLookup(variableRegistry, fakeFile, newOverrides, otherAttrs); + assertTrue(newOverriddenLookup.containsKey("filename")); + assertEquals("the real deal", newOverriddenLookup.get("fake")); + assertEquals("1", newOverriddenLookup.get("flowFileId")); + assertEquals("50", newOverriddenLookup.get("fileSize")); + assertEquals("1000", newOverriddenLookup.get("entryDate")); + assertEquals("10000", newOverriddenLookup.get("lineageStartDate")); + assertEquals("fakefile.txt", newOverriddenLookup.get("filename")); + assertEquals("done you are now overridden", newOverriddenLookup.get("override me")); + } + + private FlowFile createFlowFile() { + return new FlowFile() { + @Override + public long getId() { + return 1; + } + + @Override + public long getEntryDate() { + return 1000; + } + + @Override + public long getLineageStartDate() { + return 10000; + } + + @Override + public Long getLastQueueDate() { + return null; + } + + @Override + public boolean isPenalized() { + return false; + } + + @Override + public String getAttribute(String key) { + return getAttributes().get(key); + } + + @Override + public long getSize() { + return 50; + } + + @Override + public long getLineageStartIndex() { + return 0; + } + + @Override + public long getQueueDateIndex() { + return 0; + } + + @Override + public Map<String, String> getAttributes() { + Map<String, String> attributes = new HashMap<>(); + attributes.put("filename", "fakefile.txt"); + attributes.put("override me", "original"); + return attributes; + } + + @Override + public int compareTo(FlowFile o) { + return 0; + } + }; + } + +} http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-commons/nifi-properties/src/main/java/org/apache/nifi/util/NiFiProperties.java ---------------------------------------------------------------------- diff --git a/nifi-commons/nifi-properties/src/main/java/org/apache/nifi/util/NiFiProperties.java b/nifi-commons/nifi-properties/src/main/java/org/apache/nifi/util/NiFiProperties.java index 560d51c..a873c44 100644 --- a/nifi-commons/nifi-properties/src/main/java/org/apache/nifi/util/NiFiProperties.java +++ b/nifi-commons/nifi-properties/src/main/java/org/apache/nifi/util/NiFiProperties.java @@ -986,7 +986,7 @@ public class NiFiProperties extends Properties { return vrPropertiesPaths.toArray( new Path[vrPropertiesPaths.size()]); } else { - return null; + return new Path[]{}; } } http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-framework-api/src/main/java/org/apache/nifi/web/NiFiWebConfigurationContext.java ---------------------------------------------------------------------- diff --git a/nifi-framework-api/src/main/java/org/apache/nifi/web/NiFiWebConfigurationContext.java b/nifi-framework-api/src/main/java/org/apache/nifi/web/NiFiWebConfigurationContext.java index 889e7ac..f5b608b 100644 --- a/nifi-framework-api/src/main/java/org/apache/nifi/web/NiFiWebConfigurationContext.java +++ b/nifi-framework-api/src/main/java/org/apache/nifi/web/NiFiWebConfigurationContext.java @@ -20,13 +20,12 @@ import java.util.Collection; import java.util.Map; import org.apache.nifi.controller.ControllerService; -import org.apache.nifi.registry.VariableRegistryProvider; /** * NiFi web context providing limited access to dataflow configuration for * component custom UIs. */ -public interface NiFiWebConfigurationContext extends VariableRegistryProvider { +public interface NiFiWebConfigurationContext { /** * @param serviceIdentifier of the controller service http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-mock/src/main/java/org/apache/nifi/util/MockConfigurationContext.java ---------------------------------------------------------------------- diff --git a/nifi-mock/src/main/java/org/apache/nifi/util/MockConfigurationContext.java b/nifi-mock/src/main/java/org/apache/nifi/util/MockConfigurationContext.java index 4c3b399..74b84ad 100644 --- a/nifi-mock/src/main/java/org/apache/nifi/util/MockConfigurationContext.java +++ b/nifi-mock/src/main/java/org/apache/nifi/util/MockConfigurationContext.java @@ -34,13 +34,21 @@ public class MockConfigurationContext implements ConfigurationContext { private final ControllerService service; private final VariableRegistry variableRegistry; - public MockConfigurationContext(final Map<PropertyDescriptor, String> properties, final ControllerServiceLookup serviceLookup, - final VariableRegistry variableRegistry) { + public MockConfigurationContext(final Map<PropertyDescriptor, String> properties, + final ControllerServiceLookup serviceLookup) { + this(null, properties, serviceLookup, VariableRegistry.EMPTY_REGISTRY); + } + + public MockConfigurationContext(final Map<PropertyDescriptor, String> properties, + final ControllerServiceLookup serviceLookup, + final VariableRegistry variableRegistry) { this(null, properties, serviceLookup, variableRegistry); } - public MockConfigurationContext(final ControllerService service, final Map<PropertyDescriptor, String> properties, final ControllerServiceLookup serviceLookup, - final VariableRegistry variableRegistry) { + public MockConfigurationContext(final ControllerService service, + final Map<PropertyDescriptor, String> properties, + final ControllerServiceLookup serviceLookup, + final VariableRegistry variableRegistry) { this.service = service; this.properties = properties; this.serviceLookup = serviceLookup; http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-mock/src/main/java/org/apache/nifi/util/MockProcessContext.java ---------------------------------------------------------------------- diff --git a/nifi-mock/src/main/java/org/apache/nifi/util/MockProcessContext.java b/nifi-mock/src/main/java/org/apache/nifi/util/MockProcessContext.java index 63a5c85..8cbe1ac 100644 --- a/nifi-mock/src/main/java/org/apache/nifi/util/MockProcessContext.java +++ b/nifi-mock/src/main/java/org/apache/nifi/util/MockProcessContext.java @@ -43,6 +43,7 @@ import org.apache.nifi.processor.SchedulingContext; import org.apache.nifi.registry.VariableRegistry; import org.apache.nifi.state.MockStateManager; import org.junit.Assert; +import static java.util.Objects.requireNonNull; public class MockProcessContext extends MockControllerServiceLookup implements SchedulingContext, ControllerServiceLookup, NodeTypeProvider { @@ -65,14 +66,15 @@ public class MockProcessContext extends MockControllerServiceLookup implements S private volatile boolean isClustered; private volatile boolean isPrimaryNode; - public MockProcessContext(final ConfigurableComponent component, final VariableRegistry variableRegistry) { - this(component, new MockStateManager(component),variableRegistry); + public MockProcessContext(final ConfigurableComponent component) { + this(component, new MockStateManager(component),VariableRegistry.EMPTY_REGISTRY); } /** * Creates a new MockProcessContext for the given Processor * * @param component being mocked + * @param stateManager state manager * @param variableRegistry variableRegistry */ public MockProcessContext(final ConfigurableComponent component, final StateManager stateManager, final VariableRegistry variableRegistry) { http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-mock/src/main/java/org/apache/nifi/util/MockPropertyValue.java ---------------------------------------------------------------------- diff --git a/nifi-mock/src/main/java/org/apache/nifi/util/MockPropertyValue.java b/nifi-mock/src/main/java/org/apache/nifi/util/MockPropertyValue.java index 0fb4f89..86c6ee7 100644 --- a/nifi-mock/src/main/java/org/apache/nifi/util/MockPropertyValue.java +++ b/nifi-mock/src/main/java/org/apache/nifi/util/MockPropertyValue.java @@ -39,6 +39,14 @@ public class MockPropertyValue implements PropertyValue { private final VariableRegistry variableRegistry; private boolean expressionsEvaluated = false; + public MockPropertyValue(final String rawValue) { + this(rawValue, null); + } + + public MockPropertyValue(final String rawValue, final ControllerServiceLookup serviceLookup) { + this(rawValue, serviceLookup, VariableRegistry.EMPTY_REGISTRY, null); + } + public MockPropertyValue(final String rawValue, final ControllerServiceLookup serviceLookup, final VariableRegistry variableRegistry) { this(rawValue, serviceLookup, variableRegistry, null); } http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-mock/src/main/java/org/apache/nifi/util/MockValidationContext.java ---------------------------------------------------------------------- diff --git a/nifi-mock/src/main/java/org/apache/nifi/util/MockValidationContext.java b/nifi-mock/src/main/java/org/apache/nifi/util/MockValidationContext.java index 1a78411..fbd2a36 100644 --- a/nifi-mock/src/main/java/org/apache/nifi/util/MockValidationContext.java +++ b/nifi-mock/src/main/java/org/apache/nifi/util/MockValidationContext.java @@ -41,6 +41,10 @@ public class MockValidationContext implements ValidationContext, ControllerServi private final StateManager stateManager; private final VariableRegistry variableRegistry; + public MockValidationContext(final MockProcessContext processContext) { + this(processContext, null, VariableRegistry.EMPTY_REGISTRY); + } + public MockValidationContext(final MockProcessContext processContext, final StateManager stateManager, final VariableRegistry variableRegistry) { this.context = processContext; this.stateManager = stateManager; http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-mock/src/main/java/org/apache/nifi/util/TestRunners.java ---------------------------------------------------------------------- diff --git a/nifi-mock/src/main/java/org/apache/nifi/util/TestRunners.java b/nifi-mock/src/main/java/org/apache/nifi/util/TestRunners.java index b36f102..4b5fbd3 100644 --- a/nifi-mock/src/main/java/org/apache/nifi/util/TestRunners.java +++ b/nifi-mock/src/main/java/org/apache/nifi/util/TestRunners.java @@ -18,12 +18,11 @@ package org.apache.nifi.util; import org.apache.nifi.processor.Processor; import org.apache.nifi.registry.VariableRegistry; -import org.apache.nifi.registry.VariableRegistryUtils; public class TestRunners { public static TestRunner newTestRunner(final Processor processor) { - return newTestRunner(processor,VariableRegistryUtils.createSystemVariableRegistry()); + return newTestRunner(processor,VariableRegistry.ENVIRONMENT_SYSTEM_REGISTRY); } public static TestRunner newTestRunner(final Processor processor, VariableRegistry variableRegistry){ http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-mock/src/test/java/org/apache/nifi/util/CurrentTestStandardProcessorTestRunner.java ---------------------------------------------------------------------- diff --git a/nifi-mock/src/test/java/org/apache/nifi/util/CurrentTestStandardProcessorTestRunner.java b/nifi-mock/src/test/java/org/apache/nifi/util/CurrentTestStandardProcessorTestRunner.java index 83e22ab..4c4302b 100644 --- a/nifi-mock/src/test/java/org/apache/nifi/util/CurrentTestStandardProcessorTestRunner.java +++ b/nifi-mock/src/test/java/org/apache/nifi/util/CurrentTestStandardProcessorTestRunner.java @@ -20,7 +20,7 @@ import org.apache.nifi.processor.AbstractProcessor; import org.apache.nifi.processor.ProcessContext; import org.apache.nifi.processor.ProcessSession; import org.apache.nifi.processor.exception.ProcessException; -import org.apache.nifi.registry.VariableRegistryUtils; +import org.apache.nifi.registry.VariableRegistry; import org.junit.Assert; import org.junit.Test; @@ -32,7 +32,7 @@ public class CurrentTestStandardProcessorTestRunner { @Test public void testOnScheduledCalledAfterRunFinished() { SlowRunProcessor processor = new SlowRunProcessor(); - StandardProcessorTestRunner runner = new StandardProcessorTestRunner(processor, VariableRegistryUtils.createSystemVariableRegistry()); + StandardProcessorTestRunner runner = new StandardProcessorTestRunner(processor, VariableRegistry.ENVIRONMENT_SYSTEM_REGISTRY); final int iterations = 5; runner.run(iterations); // if the counter is not equal to iterations, the the processor must have been unscheduled http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-mock/src/test/java/org/apache/nifi/util/TestMockProcessContext.java ---------------------------------------------------------------------- diff --git a/nifi-mock/src/test/java/org/apache/nifi/util/TestMockProcessContext.java b/nifi-mock/src/test/java/org/apache/nifi/util/TestMockProcessContext.java index 3271d7f..d48af63 100644 --- a/nifi-mock/src/test/java/org/apache/nifi/util/TestMockProcessContext.java +++ b/nifi-mock/src/test/java/org/apache/nifi/util/TestMockProcessContext.java @@ -32,7 +32,6 @@ import org.apache.nifi.processor.ProcessContext; import org.apache.nifi.processor.ProcessSession; import org.apache.nifi.processor.exception.ProcessException; import org.apache.nifi.processor.util.StandardValidators; -import org.apache.nifi.registry.VariableRegistryUtils; import org.junit.Test; public class TestMockProcessContext { @@ -40,7 +39,7 @@ public class TestMockProcessContext { @Test public void testRemoveProperty() { final DummyProcessor proc = new DummyProcessor(); - final MockProcessContext context = new MockProcessContext(proc, VariableRegistryUtils.createSystemVariableRegistry()); + final MockProcessContext context = new MockProcessContext(proc); context.setProperty(DummyProcessor.REQUIRED_PROP, "req-value"); context.setProperty(DummyProcessor.OPTIONAL_PROP, "opt-value"); context.setProperty(DummyProcessor.DEFAULTED_PROP, "custom-value"); http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-nar-bundles/nifi-ambari-bundle/nifi-ambari-reporting-task/src/test/java/org/apache/nifi/reporting/ambari/TestAmbariReportingTask.java ---------------------------------------------------------------------- diff --git a/nifi-nar-bundles/nifi-ambari-bundle/nifi-ambari-reporting-task/src/test/java/org/apache/nifi/reporting/ambari/TestAmbariReportingTask.java b/nifi-nar-bundles/nifi-ambari-bundle/nifi-ambari-reporting-task/src/test/java/org/apache/nifi/reporting/ambari/TestAmbariReportingTask.java index dedfb62..5e23bf7 100644 --- a/nifi-nar-bundles/nifi-ambari-bundle/nifi-ambari-reporting-task/src/test/java/org/apache/nifi/reporting/ambari/TestAmbariReportingTask.java +++ b/nifi-nar-bundles/nifi-ambari-bundle/nifi-ambari-reporting-task/src/test/java/org/apache/nifi/reporting/ambari/TestAmbariReportingTask.java @@ -20,8 +20,6 @@ import org.apache.nifi.controller.ConfigurationContext; import org.apache.nifi.controller.status.ProcessGroupStatus; import org.apache.nifi.controller.status.ProcessorStatus; import org.apache.nifi.logging.ComponentLog; -import org.apache.nifi.registry.VariableRegistry; -import org.apache.nifi.registry.VariableRegistryUtils; import org.apache.nifi.reporting.EventAccess; import org.apache.nifi.reporting.InitializationException; import org.apache.nifi.reporting.ReportingContext; @@ -45,7 +43,6 @@ import java.util.UUID; public class TestAmbariReportingTask { private ProcessGroupStatus status; - private VariableRegistry variableRegistry; @Before public void setup() { @@ -76,7 +73,6 @@ public class TestAmbariReportingTask { Collection<ProcessGroupStatus> groupStatuses = new ArrayList<>(); groupStatuses.add(groupStatus); status.setProcessGroupStatus(groupStatuses); - variableRegistry = VariableRegistryUtils.createSystemVariableRegistry(); } @Test @@ -109,11 +105,11 @@ public class TestAmbariReportingTask { // mock the ReportingContext for onTrigger(...) final ReportingContext context = Mockito.mock(ReportingContext.class); Mockito.when(context.getProperty(AmbariReportingTask.METRICS_COLLECTOR_URL)) - .thenReturn(new MockPropertyValue(metricsUrl, null, variableRegistry)); + .thenReturn(new MockPropertyValue(metricsUrl)); Mockito.when(context.getProperty(AmbariReportingTask.APPLICATION_ID)) - .thenReturn(new MockPropertyValue(applicationId, null, variableRegistry)); + .thenReturn(new MockPropertyValue(applicationId)); Mockito.when(context.getProperty(AmbariReportingTask.HOSTNAME)) - .thenReturn(new MockPropertyValue(hostName, null, variableRegistry)); + .thenReturn(new MockPropertyValue(hostName)); final EventAccess eventAccess = Mockito.mock(EventAccess.class); http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-nar-bundles/nifi-elasticsearch-bundle/nifi-elasticsearch-processors/src/test/java/org/apache/nifi/processors/elasticsearch/TestFetchElasticsearch.java ---------------------------------------------------------------------- diff --git a/nifi-nar-bundles/nifi-elasticsearch-bundle/nifi-elasticsearch-processors/src/test/java/org/apache/nifi/processors/elasticsearch/TestFetchElasticsearch.java b/nifi-nar-bundles/nifi-elasticsearch-bundle/nifi-elasticsearch-processors/src/test/java/org/apache/nifi/processors/elasticsearch/TestFetchElasticsearch.java index 5df3c01..9b68f2e 100644 --- a/nifi-nar-bundles/nifi-elasticsearch-bundle/nifi-elasticsearch-processors/src/test/java/org/apache/nifi/processors/elasticsearch/TestFetchElasticsearch.java +++ b/nifi-nar-bundles/nifi-elasticsearch-bundle/nifi-elasticsearch-processors/src/test/java/org/apache/nifi/processors/elasticsearch/TestFetchElasticsearch.java @@ -18,8 +18,6 @@ package org.apache.nifi.processors.elasticsearch; import org.apache.nifi.processor.ProcessContext; import org.apache.nifi.processor.exception.ProcessException; -import org.apache.nifi.registry.VariableRegistry; -import org.apache.nifi.registry.VariableRegistryUtils; import org.apache.nifi.ssl.SSLContextService; import org.apache.nifi.util.MockFlowFile; import org.apache.nifi.util.MockProcessContext; @@ -64,13 +62,11 @@ public class TestFetchElasticsearch { private InputStream docExample; private TestRunner runner; - private VariableRegistry variableRegistry; @Before public void setUp() throws IOException { ClassLoader classloader = Thread.currentThread().getContextClassLoader(); docExample = classloader.getResourceAsStream("DocumentExample.json"); - variableRegistry = VariableRegistryUtils.createSystemVariableRegistry(); } @@ -220,7 +216,7 @@ public class TestFetchElasticsearch { } }; - MockProcessContext context = new MockProcessContext(processor, variableRegistry); + MockProcessContext context = new MockProcessContext(processor); processor.initialize(new MockProcessorInitializationContext(processor, context)); processor.callCreateElasticsearchClient(context); } http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-authorizer/src/main/java/org/apache/nifi/authorization/AuthorizerFactoryBean.java ---------------------------------------------------------------------- diff --git a/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-authorizer/src/main/java/org/apache/nifi/authorization/AuthorizerFactoryBean.java b/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-authorizer/src/main/java/org/apache/nifi/authorization/AuthorizerFactoryBean.java index 9cce342..ba8866d 100644 --- a/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-authorizer/src/main/java/org/apache/nifi/authorization/AuthorizerFactoryBean.java +++ b/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-authorizer/src/main/java/org/apache/nifi/authorization/AuthorizerFactoryBean.java @@ -25,7 +25,6 @@ import org.apache.nifi.authorization.generated.Authorizers; import org.apache.nifi.authorization.generated.Property; import org.apache.nifi.nar.ExtensionManager; import org.apache.nifi.nar.NarCloseable; -import org.apache.nifi.registry.VariableRegistry; import org.apache.nifi.util.NiFiProperties; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -73,7 +72,6 @@ public class AuthorizerFactoryBean implements FactoryBean, DisposableBean, Autho private Authorizer authorizer; private NiFiProperties properties; - private VariableRegistry variableRegistry; private final Map<String, Authorizer> authorizers = new HashMap<>(); @@ -192,7 +190,7 @@ public class AuthorizerFactoryBean implements FactoryBean, DisposableBean, Autho for (final Property property : authorizer.getProperty()) { authorizerProperties.put(property.getName(), property.getValue()); } - return new StandardAuthorizerConfigurationContext(authorizer.getIdentifier(), authorizerProperties, variableRegistry); + return new StandardAuthorizerConfigurationContext(authorizer.getIdentifier(), authorizerProperties); } private void performMethodInjection(final Authorizer instance, final Class authorizerClass) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException { @@ -487,7 +485,4 @@ public class AuthorizerFactoryBean implements FactoryBean, DisposableBean, Autho this.properties = properties; } - public void setVariableRegistry(VariableRegistry variableRegistry) { - this.variableRegistry = variableRegistry; - } } http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-authorizer/src/main/resources/nifi-authorizer-context.xml ---------------------------------------------------------------------- diff --git a/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-authorizer/src/main/resources/nifi-authorizer-context.xml b/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-authorizer/src/main/resources/nifi-authorizer-context.xml index 09bdf57..71bf684 100644 --- a/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-authorizer/src/main/resources/nifi-authorizer-context.xml +++ b/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-authorizer/src/main/resources/nifi-authorizer-context.xml @@ -21,7 +21,6 @@ <!-- user/entity authorizer --> <bean id="authorizer" class="org.apache.nifi.authorization.AuthorizerFactoryBean"> <property name="properties" ref="nifiProperties"/> - <property name="variableRegistry" ref="variableRegistry"/> </bean> </beans> http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-file-authorizer/src/test/java/org/apache/nifi/authorization/FileAuthorizerTest.java ---------------------------------------------------------------------- diff --git a/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-file-authorizer/src/test/java/org/apache/nifi/authorization/FileAuthorizerTest.java b/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-file-authorizer/src/test/java/org/apache/nifi/authorization/FileAuthorizerTest.java index 2c1c37a..5c77e44 100644 --- a/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-file-authorizer/src/test/java/org/apache/nifi/authorization/FileAuthorizerTest.java +++ b/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-file-authorizer/src/test/java/org/apache/nifi/authorization/FileAuthorizerTest.java @@ -21,8 +21,6 @@ import org.apache.nifi.authorization.AuthorizationResult.Result; import org.apache.nifi.authorization.exception.AuthorizerCreationException; import org.apache.nifi.authorization.resource.ResourceFactory; import org.apache.nifi.authorization.resource.ResourceType; -import org.apache.nifi.registry.VariableRegistry; -import org.apache.nifi.registry.VariableRegistryUtils; import org.apache.nifi.util.NiFiProperties; import org.apache.nifi.util.file.FileUtils; import org.junit.After; @@ -145,7 +143,6 @@ public class FileAuthorizerTest { private File flow; private File flowNoPorts; private File flowWithDns; - private VariableRegistry variableRegistry; private AuthorizerConfigurationContext configurationContext; @@ -181,8 +178,8 @@ public class FileAuthorizerTest { when(properties.getFlowConfigurationFile()).thenReturn(flow); configurationContext = mock(AuthorizerConfigurationContext.class); - when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_AUTHORIZATIONS_FILE))).thenReturn(new StandardPropertyValue(primaryAuthorizations.getPath(), null,variableRegistry)); - when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_TENANTS_FILE))).thenReturn(new StandardPropertyValue(primaryTenants.getPath(), null,variableRegistry)); + when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_AUTHORIZATIONS_FILE))).thenReturn(new StandardPropertyValue(primaryAuthorizations.getPath(), null)); + when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_TENANTS_FILE))).thenReturn(new StandardPropertyValue(primaryTenants.getPath(), null)); authorizer = new FileAuthorizer(); authorizer.setNiFiProperties(properties); @@ -200,7 +197,7 @@ public class FileAuthorizerTest { @Test public void testOnConfiguredWhenLegacyUsersFileProvidedWithOverlappingRoles() throws Exception { when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_LEGACY_AUTHORIZED_USERS_FILE))) - .thenReturn(new StandardPropertyValue("src/test/resources/authorized-users-multirole.xml", null,VariableRegistryUtils.createSystemVariableRegistry())); + .thenReturn(new StandardPropertyValue("src/test/resources/authorized-users-multirole.xml", null)); writeFile(primaryAuthorizations, EMPTY_AUTHORIZATIONS_CONCISE); writeFile(primaryTenants, EMPTY_TENANTS_CONCISE); @@ -225,7 +222,7 @@ public class FileAuthorizerTest { when(properties.getFlowConfigurationFile()).thenReturn(flowNoPorts); when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_LEGACY_AUTHORIZED_USERS_FILE))) - .thenReturn(new StandardPropertyValue("src/test/resources/authorized-users.xml", null,variableRegistry)); + .thenReturn(new StandardPropertyValue("src/test/resources/authorized-users.xml", null)); writeFile(primaryAuthorizations, EMPTY_AUTHORIZATIONS_CONCISE); writeFile(primaryTenants, EMPTY_TENANTS_CONCISE); @@ -245,7 +242,7 @@ public class FileAuthorizerTest { @Test public void testOnConfiguredWhenLegacyUsersFileProvided() throws Exception { when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_LEGACY_AUTHORIZED_USERS_FILE))) - .thenReturn(new StandardPropertyValue("src/test/resources/authorized-users.xml", null,VariableRegistryUtils.createSystemVariableRegistry())); + .thenReturn(new StandardPropertyValue("src/test/resources/authorized-users.xml", null)); writeFile(primaryAuthorizations, EMPTY_AUTHORIZATIONS_CONCISE); writeFile(primaryTenants, EMPTY_TENANTS_CONCISE); @@ -395,7 +392,7 @@ public class FileAuthorizerTest { authorizer.setNiFiProperties(properties); when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_LEGACY_AUTHORIZED_USERS_FILE))) - .thenReturn(new StandardPropertyValue("src/test/resources/authorized-users-with-dns.xml", null,variableRegistry)); + .thenReturn(new StandardPropertyValue("src/test/resources/authorized-users-with-dns.xml", null)); writeFile(primaryAuthorizations, EMPTY_AUTHORIZATIONS_CONCISE); writeFile(primaryTenants, EMPTY_TENANTS_CONCISE); @@ -443,7 +440,7 @@ public class FileAuthorizerTest { @Test(expected = AuthorizerCreationException.class) public void testOnConfiguredWhenBadLegacyUsersFileProvided() throws Exception { when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_LEGACY_AUTHORIZED_USERS_FILE))) - .thenReturn(new StandardPropertyValue("src/test/resources/does-not-exist.xml", null,VariableRegistryUtils.createSystemVariableRegistry())); + .thenReturn(new StandardPropertyValue("src/test/resources/does-not-exist.xml", null)); writeFile(primaryAuthorizations, EMPTY_AUTHORIZATIONS_CONCISE); writeFile(primaryTenants, EMPTY_TENANTS_CONCISE); @@ -453,12 +450,11 @@ public class FileAuthorizerTest { @Test(expected = AuthorizerCreationException.class) public void testOnConfiguredWhenInitialAdminAndLegacyUsersProvided() throws Exception { final String adminIdentity = "admin-user"; - final VariableRegistry variableRegistry = VariableRegistryUtils.createSystemVariableRegistry(); when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_INITIAL_ADMIN_IDENTITY))) - .thenReturn(new StandardPropertyValue(adminIdentity, null,variableRegistry)); + .thenReturn(new StandardPropertyValue(adminIdentity, null)); when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_LEGACY_AUTHORIZED_USERS_FILE))) - .thenReturn(new StandardPropertyValue("src/test/resources/authorized-users.xml", null,variableRegistry)); + .thenReturn(new StandardPropertyValue("src/test/resources/authorized-users.xml", null)); writeFile(primaryAuthorizations, EMPTY_AUTHORIZATIONS_CONCISE); writeFile(primaryTenants, EMPTY_TENANTS_CONCISE); @@ -483,7 +479,7 @@ public class FileAuthorizerTest { final String adminIdentity = "admin-user"; when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_INITIAL_ADMIN_IDENTITY))) - .thenReturn(new StandardPropertyValue(adminIdentity, null,VariableRegistryUtils.createSystemVariableRegistry())); + .thenReturn(new StandardPropertyValue(adminIdentity, null)); writeFile(primaryAuthorizations, EMPTY_AUTHORIZATIONS_CONCISE); writeFile(primaryTenants, EMPTY_TENANTS_CONCISE); @@ -513,7 +509,6 @@ public class FileAuthorizerTest { @Test public void testOnConfiguredWhenInitialAdminProvidedAndNoFlowExists() throws Exception { - VariableRegistry variableRegistry = VariableRegistryUtils.createSystemVariableRegistry(); // setup NiFi properties to return a file that does not exist properties = mock(NiFiProperties.class); when(properties.getRestoreDirectory()).thenReturn(restoreAuthorizations.getParentFile()); @@ -522,7 +517,7 @@ public class FileAuthorizerTest { final String adminIdentity = "admin-user"; when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_INITIAL_ADMIN_IDENTITY))) - .thenReturn(new StandardPropertyValue(adminIdentity, null, variableRegistry)); + .thenReturn(new StandardPropertyValue(adminIdentity, null)); writeFile(primaryAuthorizations, EMPTY_AUTHORIZATIONS_CONCISE); writeFile(primaryTenants, EMPTY_TENANTS_CONCISE); @@ -553,7 +548,6 @@ public class FileAuthorizerTest { @Test public void testOnConfiguredWhenInitialAdminProvidedAndFlowIsNull() throws Exception { // setup NiFi properties to return a file that does not exist - VariableRegistry variableRegistry = VariableRegistryUtils.createSystemVariableRegistry(); properties = mock(NiFiProperties.class); when(properties.getRestoreDirectory()).thenReturn(restoreAuthorizations.getParentFile()); when(properties.getFlowConfigurationFile()).thenReturn(null); @@ -561,7 +555,7 @@ public class FileAuthorizerTest { final String adminIdentity = "admin-user"; when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_INITIAL_ADMIN_IDENTITY))) - .thenReturn(new StandardPropertyValue(adminIdentity, null, variableRegistry)); + .thenReturn(new StandardPropertyValue(adminIdentity, null)); writeFile(primaryAuthorizations, EMPTY_AUTHORIZATIONS_CONCISE); writeFile(primaryTenants, EMPTY_TENANTS_CONCISE); @@ -602,7 +596,7 @@ public class FileAuthorizerTest { final String adminIdentity = "CN=localhost, OU=Apache NiFi, O=Apache, L=Santa Monica, ST=CA, C=US"; when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_INITIAL_ADMIN_IDENTITY))) - .thenReturn(new StandardPropertyValue(adminIdentity, null,variableRegistry)); + .thenReturn(new StandardPropertyValue(adminIdentity, null)); writeFile(primaryAuthorizations, EMPTY_AUTHORIZATIONS_CONCISE); writeFile(primaryTenants, EMPTY_TENANTS_CONCISE); @@ -620,7 +614,7 @@ public class FileAuthorizerTest { final String adminIdentity = "admin-user"; when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_INITIAL_ADMIN_IDENTITY))) - .thenReturn(new StandardPropertyValue(adminIdentity, null,VariableRegistryUtils.createSystemVariableRegistry())); + .thenReturn(new StandardPropertyValue(adminIdentity, null)); final String nodeIdentity1 = "node1"; final String nodeIdentity2 = "node2"; @@ -669,7 +663,7 @@ public class FileAuthorizerTest { final String adminIdentity = "CN=user1, OU=Apache NiFi, O=Apache, L=Santa Monica, ST=CA, C=US"; when(configurationContext.getProperty(Mockito.eq(FileAuthorizer.PROP_INITIAL_ADMIN_IDENTITY))) - .thenReturn(new StandardPropertyValue(adminIdentity, null,variableRegistry)); + .thenReturn(new StandardPropertyValue(adminIdentity, null)); final String nodeIdentity1 = "CN=node1, OU=Apache NiFi, O=Apache, L=Santa Monica, ST=CA, C=US"; final String nodeIdentity2 = "CN=node2, OU=Apache NiFi, O=Apache, L=Santa Monica, ST=CA, C=US"; http://git-wip-us.apache.org/repos/asf/nifi/blob/05a99a93/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-framework-authorization/src/main/java/org/apache/nifi/authorization/StandardAuthorizerConfigurationContext.java ---------------------------------------------------------------------- diff --git a/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-framework-authorization/src/main/java/org/apache/nifi/authorization/StandardAuthorizerConfigurationContext.java b/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-framework-authorization/src/main/java/org/apache/nifi/authorization/StandardAuthorizerConfigurationContext.java index abe532a..3010c92 100644 --- a/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-framework-authorization/src/main/java/org/apache/nifi/authorization/StandardAuthorizerConfigurationContext.java +++ b/nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-framework-authorization/src/main/java/org/apache/nifi/authorization/StandardAuthorizerConfigurationContext.java @@ -18,7 +18,6 @@ package org.apache.nifi.authorization; import org.apache.nifi.attribute.expression.language.StandardPropertyValue; import org.apache.nifi.components.PropertyValue; -import org.apache.nifi.registry.VariableRegistry; import java.util.Collections; import java.util.HashMap; @@ -31,12 +30,10 @@ public class StandardAuthorizerConfigurationContext implements AuthorizerConfigu private final String identifier; private final Map<String, String> properties; - final VariableRegistry variableRegistry; - public StandardAuthorizerConfigurationContext(String identifier, Map<String, String> properties, VariableRegistry variableRegistry) { + public StandardAuthorizerConfigurationContext(String identifier, Map<String, String> properties) { this.identifier = identifier; this.properties = Collections.unmodifiableMap(new HashMap<String, String>(properties)); - this.variableRegistry = variableRegistry; } @Override @@ -51,7 +48,7 @@ public class StandardAuthorizerConfigurationContext implements AuthorizerConfigu @Override public PropertyValue getProperty(String property) { - return new StandardPropertyValue(properties.get(property), null,variableRegistry); + return new StandardPropertyValue(properties.get(property), null); } }
