You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@accumulo.apache.org by kt...@apache.org on 2026/01/12 23:37:29 UTC
(accumulo-access) branch main updated: Modified accumulo access to only work with String and Unicode. (#96)
This is an automated email from the ASF dual-hosted git repository.
kturner pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/accumulo-access.git
The following commit(s) were added to refs/heads/main by this push:
new 7049bc7 Modified accumulo access to only work with String and Unicode. (#96)
7049bc7 is described below
commit 7049bc73ebdd780998c2703964e7848e1d21f434
Author: Keith Turner <kt...@apache.org>
AuthorDate: Mon Jan 12 15:37:20 2026 -0800
Modified accumulo access to only work with String and Unicode. (#96)
---
SPECIFICATION.md | 14 +-
.../antlr4/AccessExpressionAntlrEvaluator.java | 15 +-
.../antlr/AccessExpressionAntlrBenchmark.java | 10 +-
.../accumulo/access/grammar/antlr/Antlr4Tests.java | 55 +----
.../java/org/apache/accumulo/access/Access.java | 219 +++++++++++++++++
.../apache/accumulo/access/AccessEvaluator.java | 85 -------
.../apache/accumulo/access/AccessExpression.java | 258 +--------------------
.../accumulo/access/AuthorizationValidator.java | 115 +++++++++
.../org/apache/accumulo/access/Authorizations.java | 72 +-----
.../access/InvalidAccessExpressionException.java | 3 +-
.../access/InvalidAuthorizationException.java | 28 +++
.../accumulo/access/ParsedAccessExpression.java | 6 +-
.../accumulo/access/impl/AccessEvaluatorImpl.java | 103 ++++----
.../accumulo/access/impl/AccessExpressionImpl.java | 46 +++-
.../apache/accumulo/access/impl/AccessImpl.java | 117 ++++++++++
.../accumulo/access/impl/AuthorizationsImpl.java | 52 +++++
.../apache/accumulo/access/impl/BuilderImpl.java | 40 ++++
.../access/impl/{ByteUtils.java => CharUtils.java} | 24 +-
.../impl/{BytesWrapper.java => CharsWrapper.java} | 95 ++++----
.../access/impl/MultiAccessEvaluatorImpl.java | 17 +-
.../access/impl/ParsedAccessExpressionImpl.java | 81 ++++---
.../accumulo/access/impl/ParserEvaluator.java | 86 +++++--
.../org/apache/accumulo/access/impl/Tokenizer.java | 65 +++---
.../access/specification/AccessExpression.abnf | 5 +-
.../accumulo/access/tests/AccessEvaluatorTest.java | 166 +++++++------
.../access/tests/AccessExpressionBenchmark.java | 40 ++--
.../access/tests/AccessExpressionTest.java | 86 ++++---
.../accumulo/access/tests/AuthorizationTest.java | 256 +++++++++++++++++++-
.../access/tests/ParsedAccessExpressionTest.java | 42 ++--
.../accumulo/access/examples/AccessExample.java | 8 +-
.../accumulo/access/examples/ParseExamples.java | 18 +-
.../access/examples/test/ParseExamplesTest.java | 13 +-
src/build/ci/spotbugs-exclude.xml | 5 +
33 files changed, 1383 insertions(+), 862 deletions(-)
diff --git a/SPECIFICATION.md b/SPECIFICATION.md
index eae4e08..6869625 100644
--- a/SPECIFICATION.md
+++ b/SPECIFICATION.md
@@ -49,14 +49,17 @@ and-expression = "&" (access-token / paren-expression) [and-expression
or-expression = "|" (access-token / paren-expression) [or-expression]
access-token = 1*( ALPHA / DIGIT / "_" / "-" / "." / ":" / slash )
-access-token =/ DQUOTE 1*(utf8-subset / escaped) DQUOTE
+access-token =/ DQUOTE 1*(unicode-subset / escaped) DQUOTE
-utf8-subset = %x20-21 / %x23-5B / %x5D-7E / unicode-beyond-ascii ; utf8 minus '"' and '\'
-unicode-beyond-ascii = %x0080-D7FF / %xE000-10FFFF
+unicode-subset = %x00-21 / %x23-5B / %x5D-7F / unicode-beyond-ascii ; unicode minus '"' and '\'
escaped = "\" DQUOTE / "\\"
slash = "/"
```
+Authorizations must be Unicode characters. Not all Unicode characters are human readable or even visible
+(see [Unicode control characters][6]), implementations should provide a way to limit valid authorizations to
+a subset of unicode characters (like human-readable characters).
+
### Examples of Proper Expressions
* `BLUE`
@@ -73,8 +76,8 @@ slash = "/"
## Serialization
-An AccessExpression is a UTF-8 string. It can be serialized using a byte array as long as it
-can be deserialized back into the same UTF-8 string.
+An access expression or authorization must be a Unicode string. Serialization of an access expression or authorization
+should use UTF-8.
## Evaluation
@@ -140,3 +143,4 @@ within the Authorizations object, the token is unquoted, and the `\` character i
[3]: https://en.wikipedia.org/wiki/Boolean_algebra
[4]: https://en.wikipedia.org/wiki/Logical_conjunction
[5]: https://en.wikipedia.org/wiki/Logical_disjunction
+[6]: https://en.wikipedia.org/wiki/Unicode_control_characters
diff --git a/antlr4-example/src/main/java/org/apache/accumulo/access/antlr4/AccessExpressionAntlrEvaluator.java b/antlr4-example/src/main/java/org/apache/accumulo/access/antlr4/AccessExpressionAntlrEvaluator.java
index 0d1ba19..d9bd39e 100644
--- a/antlr4-example/src/main/java/org/apache/accumulo/access/antlr4/AccessExpressionAntlrEvaluator.java
+++ b/antlr4-example/src/main/java/org/apache/accumulo/access/antlr4/AccessExpressionAntlrEvaluator.java
@@ -25,9 +25,8 @@ import java.util.Set;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.TerminalNode;
-import org.apache.accumulo.access.AccessExpression;
+import org.apache.accumulo.access.Access;
import org.apache.accumulo.access.Authorizations;
-import org.apache.accumulo.access.InvalidAccessExpressionException;
import org.apache.accumulo.access.grammars.AccessExpressionParser.Access_expressionContext;
import org.apache.accumulo.access.grammars.AccessExpressionParser.Access_tokenContext;
import org.apache.accumulo.access.grammars.AccessExpressionParser.And_expressionContext;
@@ -37,6 +36,8 @@ import org.apache.accumulo.access.grammars.AccessExpressionParser.Or_operatorCon
public class AccessExpressionAntlrEvaluator {
+ public static final Access ACCESS = Access.builder().build();
+
private class Entity {
private Set<String> authorizations;
@@ -60,7 +61,7 @@ public class AccessExpressionAntlrEvaluator {
e.authorizations = new HashSet<>(entityAuths.size() * 2);
a.asSet().stream().forEach(auth -> {
e.authorizations.add(auth);
- String quoted = AccessExpression.quote(auth);
+ String quoted = ACCESS.quote(auth);
if (!quoted.startsWith("\"")) {
quoted = '"' + quoted + '"';
}
@@ -69,14 +70,6 @@ public class AccessExpressionAntlrEvaluator {
}
}
- public boolean canAccess(byte[] accessExpression) throws InvalidAccessExpressionException {
- return canAccess(AccessExpression.of(accessExpression));
- }
-
- public boolean canAccess(AccessExpression accessExpression) {
- return canAccess(accessExpression.getExpression());
- }
-
public boolean canAccess(String accessExpression) {
if ("".equals(accessExpression)) {
return true;
diff --git a/antlr4-example/src/test/java/org/apache/accumulo/access/grammar/antlr/AccessExpressionAntlrBenchmark.java b/antlr4-example/src/test/java/org/apache/accumulo/access/grammar/antlr/AccessExpressionAntlrBenchmark.java
index e32593a..acf4905 100644
--- a/antlr4-example/src/test/java/org/apache/accumulo/access/grammar/antlr/AccessExpressionAntlrBenchmark.java
+++ b/antlr4-example/src/test/java/org/apache/accumulo/access/grammar/antlr/AccessExpressionAntlrBenchmark.java
@@ -19,6 +19,7 @@
package org.apache.accumulo.access.grammar.antlr;
import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.apache.accumulo.access.grammar.antlr.Antlr4Tests.ACCESS;
import java.io.IOException;
import java.net.URISyntaxException;
@@ -29,7 +30,6 @@ import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.Stream;
-import org.apache.accumulo.access.Authorizations;
import org.apache.accumulo.access.antlr.TestDataLoader;
import org.apache.accumulo.access.antlr4.AccessExpressionAntlrEvaluator;
import org.apache.accumulo.access.antlr4.AccessExpressionAntlrParser;
@@ -64,7 +64,7 @@ public class AccessExpressionAntlrBenchmark {
List<Access_expressionContext> parsedExpressions;
- List<byte[]> expressions;
+ List<String> expressions;
}
@State(Scope.Benchmark)
@@ -89,7 +89,7 @@ public class AccessExpressionAntlrBenchmark {
et.expressions = new ArrayList<>();
et.evaluator = new AccessExpressionAntlrEvaluator(Stream.of(testDataSet.auths)
- .map(a -> Authorizations.of(Set.of(a))).collect(Collectors.toList()));
+ .map(a -> ACCESS.newAuthorizations(Set.of(a))).collect(Collectors.toList()));
for (var tests : testDataSet.tests) {
if (tests.expectedResult != TestDataLoader.ExpectedResult.ERROR) {
@@ -97,7 +97,7 @@ public class AccessExpressionAntlrBenchmark {
allTestExpressionsStr.add(exp);
byte[] byteExp = exp.getBytes(UTF_8);
allTestExpressions.add(byteExp);
- et.expressions.add(byteExp);
+ et.expressions.add(exp);
et.parsedExpressions.add(AccessExpressionAntlrParser.parseAccessExpression(exp));
}
}
@@ -160,7 +160,7 @@ public class AccessExpressionAntlrBenchmark {
@Benchmark
public void measureEvaluationAndParsing(BenchmarkState state, Blackhole blackhole) {
for (EvaluatorTests evaluatorTests : state.getEvaluatorTests()) {
- for (byte[] expression : evaluatorTests.expressions) {
+ for (String expression : evaluatorTests.expressions) {
blackhole.consume(evaluatorTests.evaluator.canAccess(expression));
}
}
diff --git a/antlr4-example/src/test/java/org/apache/accumulo/access/grammar/antlr/Antlr4Tests.java b/antlr4-example/src/test/java/org/apache/accumulo/access/grammar/antlr/Antlr4Tests.java
index 3ed6a9e..6d74196 100644
--- a/antlr4-example/src/test/java/org/apache/accumulo/access/grammar/antlr/Antlr4Tests.java
+++ b/antlr4-example/src/test/java/org/apache/accumulo/access/grammar/antlr/Antlr4Tests.java
@@ -18,7 +18,6 @@
*/
package org.apache.accumulo.access.grammar.antlr;
-import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
@@ -40,7 +39,7 @@ import org.antlr.v4.runtime.LexerNoViableAltException;
import org.antlr.v4.runtime.RecognitionException;
import org.antlr.v4.runtime.Recognizer;
import org.apache.accumulo.access.AccessEvaluator;
-import org.apache.accumulo.access.AccessExpression;
+import org.apache.accumulo.access.Access;
import org.apache.accumulo.access.Authorizations;
import org.apache.accumulo.access.InvalidAccessExpressionException;
import org.apache.accumulo.access.antlr.TestDataLoader;
@@ -55,6 +54,8 @@ import org.junit.jupiter.api.Test;
public class Antlr4Tests {
+ public static final Access ACCESS = Access.builder().build();
+
private void testParse(String input) throws Exception {
CodePointCharStream expression = CharStreams.fromString(input);
final AtomicLong errors = new AtomicLong(0);
@@ -108,10 +109,10 @@ public class Antlr4Tests {
ExpectedResult result = test.expectedResult;
for (String cv : test.expressions) {
if (result == ExpectedResult.ERROR) {
- assertThrows(InvalidAccessExpressionException.class, () -> AccessExpression.of(cv));
+ assertThrows(InvalidAccessExpressionException.class, () -> ACCESS.newExpression(cv));
assertThrows(AssertionError.class, () -> testParse(cv));
} else {
- AccessExpression.of(cv);
+ ACCESS.validateExpression(cv);
testParse(cv);
}
}
@@ -122,7 +123,7 @@ public class Antlr4Tests {
@Test
public void testSimpleEvaluation() throws Exception {
String accessExpression = "(one&two)|(foo&bar)";
- Authorizations auths = Authorizations.of(Set.of("four", "three", "one", "two"));
+ Authorizations auths = ACCESS.newAuthorizations(Set.of("four", "three", "one", "two"));
AccessExpressionAntlrEvaluator eval = new AccessExpressionAntlrEvaluator(List.of(auths));
assertTrue(eval.canAccess(accessExpression));
}
@@ -130,7 +131,7 @@ public class Antlr4Tests {
@Test
public void testSimpleEvaluationFailure() throws Exception {
String accessExpression = "(A&B&C)";
- Authorizations auths = Authorizations.of(Set.of("A", "C"));
+ Authorizations auths = ACCESS.newAuthorizations(Set.of("A", "C"));
AccessExpressionAntlrEvaluator eval = new AccessExpressionAntlrEvaluator(List.of(auths));
assertFalse(eval.canAccess(accessExpression));
}
@@ -143,8 +144,8 @@ public class Antlr4Tests {
for (TestDataSet testSet : testData) {
List<Authorizations> authSets = Stream.of(testSet.auths)
- .map(a -> Authorizations.of(Set.of(a))).collect(Collectors.toList());
- AccessEvaluator evaluator = AccessEvaluator.of(authSets);
+ .map(a -> ACCESS.newAuthorizations(Set.of(a))).collect(Collectors.toList());
+ AccessEvaluator evaluator = ACCESS.newEvaluator(authSets);
AccessExpressionAntlrEvaluator antlr = new AccessExpressionAntlrEvaluator(authSets);
for (TestExpressions test : testSet.tests) {
@@ -152,58 +153,20 @@ public class Antlr4Tests {
switch (test.expectedResult) {
case ACCESSIBLE:
assertTrue(evaluator.canAccess(expression), expression);
- assertTrue(evaluator.canAccess(expression.getBytes(UTF_8)), expression);
- assertTrue(evaluator.canAccess(AccessExpression.of(expression)), expression);
- assertTrue(evaluator.canAccess(AccessExpression.of(expression.getBytes(UTF_8))),
- expression);
- assertEquals(expression,
- AccessExpression.of(expression.getBytes(UTF_8)).getExpression());
- assertEquals(expression, AccessExpression.of(expression).getExpression());
-
assertTrue(antlr.canAccess(expression), expression);
- assertTrue(antlr.canAccess(expression.getBytes(UTF_8)), expression);
- assertTrue(antlr.canAccess(AccessExpression.of(expression)), expression);
- assertTrue(antlr.canAccess(AccessExpression.of(expression.getBytes(UTF_8))),
- expression);
break;
case INACCESSIBLE:
assertFalse(evaluator.canAccess(expression), expression);
- assertFalse(evaluator.canAccess(expression.getBytes(UTF_8)), expression);
- assertFalse(evaluator.canAccess(AccessExpression.of(expression)), expression);
- assertFalse(evaluator.canAccess(AccessExpression.of(expression.getBytes(UTF_8))),
- expression);
- assertEquals(expression,
- AccessExpression.of(expression.getBytes(UTF_8)).getExpression());
- assertEquals(expression, AccessExpression.of(expression).getExpression());
-
assertFalse(antlr.canAccess(expression), expression);
- assertFalse(antlr.canAccess(expression.getBytes(UTF_8)), expression);
- assertFalse(antlr.canAccess(AccessExpression.of(expression)), expression);
- assertFalse(antlr.canAccess(AccessExpression.of(expression.getBytes(UTF_8))),
- expression);
break;
case ERROR:
assertThrows(InvalidAccessExpressionException.class,
() -> evaluator.canAccess(expression), expression);
- assertThrows(InvalidAccessExpressionException.class,
- () -> evaluator.canAccess(expression.getBytes(UTF_8)), expression);
- assertThrows(InvalidAccessExpressionException.class,
- () -> evaluator.canAccess(AccessExpression.of(expression)), expression);
- assertThrows(InvalidAccessExpressionException.class,
- () -> evaluator.canAccess(AccessExpression.of(expression.getBytes(UTF_8))),
- expression);
assertThrows(InvalidAccessExpressionException.class,
() -> antlr.canAccess(expression), expression);
- assertThrows(InvalidAccessExpressionException.class,
- () -> antlr.canAccess(expression.getBytes(UTF_8)), expression);
- assertThrows(InvalidAccessExpressionException.class,
- () -> antlr.canAccess(AccessExpression.of(expression)), expression);
- assertThrows(InvalidAccessExpressionException.class,
- () -> antlr.canAccess(AccessExpression.of(expression.getBytes(UTF_8))),
- expression);
break;
default:
throw new IllegalArgumentException();
diff --git a/core/src/main/java/org/apache/accumulo/access/Access.java b/core/src/main/java/org/apache/accumulo/access/Access.java
new file mode 100644
index 0000000..4f35f23
--- /dev/null
+++ b/core/src/main/java/org/apache/accumulo/access/Access.java
@@ -0,0 +1,219 @@
+/*
+ * 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
+ *
+ * https://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.accumulo.access;
+
+import java.util.Collection;
+import java.util.Set;
+import java.util.function.Consumer;
+
+import org.apache.accumulo.access.impl.BuilderImpl;
+
+/**
+ * The entry point into Accumulo Access to create access expressions, expression evaluators, and
+ * authorization sets.
+ *
+ * @see #builder()
+ * @since 1.0
+ */
+public interface Access {
+
+ interface Builder {
+ /**
+ * Provide a validator to accumulo access to narrow the set of valid authorizations for your
+ * specific use case. If one is not provided then {@link AuthorizationValidator#DEFAULT} will be
+ * used.
+ *
+ * <p>
+ * The provided validator is called very frequently within accumulo access and implementations
+ * that are slow will slow down accumulo access.
+ */
+ Builder authorizationValidator(AuthorizationValidator validator);
+
+ Access build();
+ }
+
+ /**
+ * Used to create an instance of AccumuloAccess. For efficiency, the recommend way to use this is
+ * to create a single instance and somehow make it available to an entire project for use. In
+ * addition to being efficient this ensures the entire project is using the same configuration.
+ */
+ static Builder builder() {
+ return new BuilderImpl();
+ }
+
+ /**
+ * Validates an access expression and returns an immutable AccessExpression object. If passing
+ * access expressions as arguments in code, consider using this type instead of a String. The
+ * advantage of passing this type over a String is that its known to be a valid expression. Also,
+ * this type is much more informative than a String type. Conceptually this method calls
+ * {@link #validateExpression(String)} and if that passes creates an immutable object that wraps
+ * the expression.
+ *
+ * @throws InvalidAccessExpressionException if the given expression is not valid
+ * @throws InvalidAuthorizationException when the expression contains an authorization that is not
+ * valid
+ * @throws NullPointerException when the argument is null
+ */
+ AccessExpression newExpression(String expression)
+ throws InvalidAccessExpressionException, InvalidAuthorizationException;
+
+ /**
+ * Quickly validates that an access expression is properly formed.
+ *
+ * @param expression a potential access expression that
+ * @throws InvalidAccessExpressionException if the given expression is not valid
+ * @throws InvalidAuthorizationException if the expression contains an invalid authorization
+ * @throws NullPointerException when the argument is null
+ */
+ void validateExpression(String expression)
+ throws InvalidAccessExpressionException, InvalidAuthorizationException;
+
+ /**
+ * Validates an access expression and returns an immutable object with a parse tree. Creating the
+ * parse tree is expensive relative to calling {@link #newExpression(String)} or
+ * {@link #validateExpression(String)}, so only use this method when the parse tree is always
+ * needed. If the code may only use the parse tree sometimes, then it may be best to call
+ * {@link #newExpression(String)} to create the access expression and then call
+ * {@link AccessExpression#parse()} when needed.
+ *
+ * @throws NullPointerException when the argument is null
+ * @throws InvalidAuthorizationException when the expression contains an authorization that is not
+ * valid
+ * @throws InvalidAccessExpressionException if the given expression is not valid
+ */
+ ParsedAccessExpression newParsedExpression(String expression)
+ throws InvalidAccessExpressionException, InvalidAuthorizationException;
+
+ /**
+ * Creates an Authorizations object from the set of input authorization strings.
+ *
+ * @param authorizations set of authorization strings
+ * @throws InvalidAuthorizationException when the expression contains an authorization that is not
+ * valid
+ * @return Authorizations object
+ */
+ Authorizations newAuthorizations(Set<String> authorizations) throws InvalidAuthorizationException;
+
+ /**
+ * Validates an access expression and finds all authorizations in it passing them to the
+ * authorizationConsumer. For example, for the expression {@code (A&B)|(A&C)|(A&D)}, this method
+ * would pass {@code A,B,A,C,A,D} to the consumer one at a time. The function will conceptually
+ * call {@link #unquote(String)} prior to passing an authorization to authorizationConsumer.
+ *
+ * <p>
+ * What this method does could also be accomplished by creating a parse tree using
+ * {@link Access#newParsedExpression(String)} and then recursively walking the parse tree. The
+ * implementation of this method does not create a parse tree and is much faster. If a parse tree
+ * is already available, then it would likely be faster to use it rather than call this method.
+ * </p>
+ *
+ * @throws InvalidAccessExpressionException when the expression is not valid.
+ * @throws InvalidAuthorizationException when the expression contains an authorization that is not
+ * valid
+ * @throws NullPointerException when any argument is null
+ */
+ void findAuthorizations(String expression, Consumer<String> authorizationConsumer)
+ throws InvalidAccessExpressionException, InvalidAuthorizationException;
+
+ /**
+ * Authorizations occurring in an access expression can only contain the characters listed in the
+ * <a href=
+ * "https://github.com/apache/accumulo-access/blob/main/SPECIFICATION.md">specification</a> unless
+ * quoted (surrounded by quotation marks). Use this method to quote authorizations that occur in
+ * an access expression. This method will only quote if it is needed.
+ *
+ * @throws NullPointerException when the argument is null
+ */
+ String quote(String authorization) throws InvalidAuthorizationException;
+
+ /**
+ * Reverses what {@link #quote(String)} does, so will unquote and unescape an authorization if
+ * needed. If the authorization is not quoted then it is returned as-is.
+ *
+ * @throws NullPointerException when the argument is null
+ */
+ String unquote(String authorization) throws InvalidAuthorizationException;
+
+ /**
+ * Creates an AccessEvaluator from an Authorizations object
+ *
+ * @param authorizations auths to use in the AccessEvaluator
+ * @return AccessEvaluator object
+ */
+ AccessEvaluator newEvaluator(Authorizations authorizations);
+
+ /**
+ * Creates an AccessEvaluator from an Authorizer
+ *
+ * @param authorizer authorizer to use in the AccessEvaluator
+ * @return AccessEvaluator object
+ */
+ AccessEvaluator newEvaluator(AccessEvaluator.Authorizer authorizer);
+
+ /**
+ * Creates an AccessEvaluator from multiple sets of authorizations. Each expression will be
+ * evaluated independently against each set of authorizations and will only be deemed accessible
+ * if accessible for all. For example the following code would print false, true, and then false.
+ *
+ * <pre>
+ * {@code
+ * AccumuloAccess accumuloAccess = ...;
+ * Collection<Authorizations> authSets =
+ * List.of(Authorizations.of("A", "B"), Authorizations.of("C", "D"));
+ * var evaluator = accumuloAccess.newEvaluator(authSets);
+ *
+ * System.out.println(evaluator.canAccess("A"));
+ * System.out.println(evaluator.canAccess("A|D"));
+ * System.out.println(evaluator.canAccess("A&D"));
+ *
+ * }
+ * </pre>
+ *
+ * <p>
+ * The following table shows how each expression in the example above will evaluate for each
+ * authorization set. In order to return true for {@code canAccess()} the expression must evaluate
+ * to true for each authorization set.
+ *
+ * <table>
+ * <caption>Evaluations</caption>
+ * <tr>
+ * <td></td>
+ * <td>[A,B]</td>
+ * <td>[C,D]</td>
+ * </tr>
+ * <tr>
+ * <td>A</td>
+ * <td>True</td>
+ * <td>False</td>
+ * </tr>
+ * <tr>
+ * <td>A|D</td>
+ * <td>True</td>
+ * <td>True</td>
+ * </tr>
+ * <tr>
+ * <td>A&D</td>
+ * <td>False</td>
+ * <td>False</td>
+ * </tr>
+ *
+ * </table>
+ */
+ AccessEvaluator newEvaluator(Collection<Authorizations> authorizationSets);
+}
diff --git a/core/src/main/java/org/apache/accumulo/access/AccessEvaluator.java b/core/src/main/java/org/apache/accumulo/access/AccessEvaluator.java
index ea0fb2c..faa3472 100644
--- a/core/src/main/java/org/apache/accumulo/access/AccessEvaluator.java
+++ b/core/src/main/java/org/apache/accumulo/access/AccessEvaluator.java
@@ -18,8 +18,6 @@
*/
package org.apache.accumulo.access;
-import java.util.Collection;
-
import org.apache.accumulo.access.impl.AccessEvaluatorImpl;
import org.apache.accumulo.access.impl.MultiAccessEvaluatorImpl;
@@ -65,14 +63,6 @@ public sealed interface AccessEvaluator permits AccessEvaluatorImpl, MultiAccess
*/
boolean canAccess(String accessExpression) throws InvalidAccessExpressionException;
- /**
- * @param accessExpression for this parameter a valid access expression is expected.
- * @return true if the expression is visible using the authorizations supplied at creation, false
- * otherwise
- * @throws InvalidAccessExpressionException when the expression is not valid
- */
- boolean canAccess(byte[] accessExpression) throws InvalidAccessExpressionException;
-
/**
* @param accessExpression previously validated access expression
* @return true if the expression is visible using the authorizations supplied at creation, false
@@ -80,81 +70,6 @@ public sealed interface AccessEvaluator permits AccessEvaluatorImpl, MultiAccess
*/
boolean canAccess(AccessExpression accessExpression);
- /**
- * Creates an AccessEvaluator from an Authorizations object
- *
- * @param authorizations auths to use in the AccessEvaluator
- * @return AccessEvaluator object
- */
- static AccessEvaluator of(Authorizations authorizations) {
- return new AccessEvaluatorImpl(authorizations);
- }
-
- /**
- * Creates an AccessEvaluator from an Authorizer object
- *
- * @param authorizer authorizer to use in the AccessEvaluator
- * @return AccessEvaluator object
- */
- static AccessEvaluator of(Authorizer authorizer) {
- return new AccessEvaluatorImpl(authorizer);
- }
-
- /**
- * Allows providing multiple sets of authorizations. Each expression will be evaluated
- * independently against each set of authorizations and will only be deemed accessible if
- * accessible for all. For example the following code would print false, true, and then false.
- *
- * <pre>
- * {@code
- * Collection<Authorizations> authSets =
- * List.of(Authorizations.of("A", "B"), Authorizations.of("C", "D"));
- * var evaluator = AccessEvaluator.of(authSets);
- *
- * System.out.println(evaluator.canAccess("A"));
- * System.out.println(evaluator.canAccess("A|D"));
- * System.out.println(evaluator.canAccess("A&D"));
- *
- * }
- * </pre>
- *
- * <p>
- * The following table shows how each expression in the example above will evaluate for each
- * authorization set. In order to return true for {@code canAccess()} the expression must evaluate
- * to true for each authorization set.
- *
- * <table>
- * <caption>Evaluations</caption>
- * <tr>
- * <td></td>
- * <td>[A,B]</td>
- * <td>[C,D]</td>
- * </tr>
- * <tr>
- * <td>A</td>
- * <td>True</td>
- * <td>False</td>
- * </tr>
- * <tr>
- * <td>A|D</td>
- * <td>True</td>
- * <td>True</td>
- * </tr>
- * <tr>
- * <td>A&D</td>
- * <td>False</td>
- * <td>False</td>
- * </tr>
- *
- * </table>
- *
- *
- *
- */
- static AccessEvaluator of(Collection<Authorizations> authorizationSets) {
- return MultiAccessEvaluatorImpl.of(authorizationSets);
- }
-
/**
* An interface that is used to check if an authorization seen in an access expression is
* authorized.
diff --git a/core/src/main/java/org/apache/accumulo/access/AccessExpression.java b/core/src/main/java/org/apache/accumulo/access/AccessExpression.java
index cf32670..7c7de37 100644
--- a/core/src/main/java/org/apache/accumulo/access/AccessExpression.java
+++ b/core/src/main/java/org/apache/accumulo/access/AccessExpression.java
@@ -18,87 +18,13 @@
*/
package org.apache.accumulo.access;
-import static java.nio.charset.StandardCharsets.UTF_8;
-
import java.io.Serializable;
-import java.util.Arrays;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-import org.apache.accumulo.access.impl.AccessEvaluatorImpl;
import org.apache.accumulo.access.impl.AccessExpressionImpl;
-import org.apache.accumulo.access.impl.BytesWrapper;
-import org.apache.accumulo.access.impl.ParsedAccessExpressionImpl;
-import org.apache.accumulo.access.impl.ParserEvaluator;
-import org.apache.accumulo.access.impl.Tokenizer;
/**
- * This class offers the ability to operate on access expressions.
- *
- * <p>
- * Below is an example of how to use this API.
- *
- * <pre>
- * {@code
- * // The following authorization does not need quoting
- * // so the return value is the same as the input.
- * var auth1 = AccessExpression.quote("CAT");
- *
- * // The following two authorizations need quoting and the return values will be quoted.
- * var auth2 = AccessExpression.quote("π¦");
- * var auth3 = AccessExpression.quote("π¦");
- *
- * // Create an AccessExpression using auth1, auth2, and auth3
- * var exp = "(" + auth1 + "&" + auth3 + ")|(" + auth1 + "&" + auth2 + ")";
- *
- * // Validate the expression w/o creating an object
- * AccessExpression.validate(exp);
- * System.out.println(exp);
- *
- * // Validate the expression and create an immutable AccessExpression object. This object can be passed around in code and other code knows it valid and does not need to revalidate.
- * AccessExpression accessExpression = AccessExpression.of(exp);
- * System.out.println(accessExpression);
- *
- * // Print the authorization in the expression
- * AccessExpression.findAuthorizations(exp, System.out::println);
- *
- * // Create an AccessExpression with a parse tree. Creating this is more expensive than calling AccessExpression.of(), so it should only be used if the parse tree is needed.
- * ParsedAccessExpression parsed = AccessExpression.parse(exp);
- * System.out.println("type:"+parsed.getType()+" child[0]:"+parsed.getChildren().get(0)+" child[1]:"+ child[1]:"+parsed.getChildren().get(1));
- *
- * }
- * </pre>
+ * An immutable wrapper for a validated access expression.
*
- * The above example will print the following.
- *
- * <pre>
- * {@code
- * (CAT&"π¦")|(CAT&"π¦")
- * (CAT&"π¦")|(CAT&"π¦")
- * CAT
- * π¦
- * CAT
- * π¦
- * type:OR child[0]:CAT&"π¦" child[1]:CAT&"π¦"
- * }
- * </pre>
- *
- * The following code will throw an {@link InvalidAccessExpressionException} because the expression
- * is not valid.
- *
- * <pre>
- * {@code
- * AccessExpression.validate("A&B|C");
- * }
- * </pre>
- *
- * <p>
- * Instances of this class are thread-safe.
- *
- * <p>
- * Note: The underlying implementation uses UTF-8 when converting between bytes and Strings.
- *
- * @see <a href="https://github.com/apache/accumulo-access">Accumulo Access Documentation</a>
* @since 1.0.0
*/
public sealed abstract class AccessExpression implements Serializable
@@ -115,10 +41,10 @@ public sealed abstract class AccessExpression implements Serializable
/**
* Parses the access expression if it was never parsed before. If this access expression was
- * created using {@link #parse(String)} or {@link #parse(byte[])} then it will have a parse from
+ * created using {@link Access#newParsedExpression(String)} then it will have a parse from
* inception and this method will return itself. If the access expression was created using
- * {@link #of(String)} or {@link #of(byte[])} then this method will create a parse tree the first
- * time its called and remember it, returning the remembered parse tree on subsequent calls.
+ * {@link Access#newExpression(String)} then this method will create a parse tree the first time
+ * its called and remember it, returning the remembered parse tree on subsequent calls.
*/
public abstract ParsedAccessExpression parse();
@@ -140,180 +66,4 @@ public sealed abstract class AccessExpression implements Serializable
public String toString() {
return getExpression();
}
-
- /**
- * Validates an access expression and returns an immutable AccessExpression object. If passing
- * access expressions as arguments in code, consider using this type instead of a String. The
- * advantage of passing this type over a String is that its known to be a valid expression. Also
- * this type is much more informative than a String type. Conceptually this method calls
- * {@link #validate(String)} and if that passes creates an immutable object that wraps the
- * expression.
- *
- * @throws InvalidAccessExpressionException if the given expression is not valid
- * @throws NullPointerException when the argument is null
- */
- public static AccessExpression of(String expression) throws InvalidAccessExpressionException {
- return new AccessExpressionImpl(expression);
- }
-
- /**
- * @see #of(String)
- */
- public static AccessExpression of(byte[] expression) throws InvalidAccessExpressionException {
- return new AccessExpressionImpl(expression);
- }
-
- /**
- * @return an empty AccessExpression that is immutable.
- */
- public static AccessExpression of() {
- return AccessExpressionImpl.EMPTY;
- }
-
- /**
- * @see #parse(String)
- */
- public static ParsedAccessExpression parse(byte[] expression)
- throws InvalidAccessExpressionException {
- if (expression.length == 0) {
- return ParsedAccessExpressionImpl.EMPTY;
- }
-
- return ParsedAccessExpressionImpl.parseExpression(Arrays.copyOf(expression, expression.length));
- }
-
- /**
- * Validates an access expression and returns an immutable object with a parse tree. Creating the
- * parse tree is expensive relative to calling {@link #of(String)} or {@link #validate(String)},
- * so only use this method when the parse tree is always needed. If the code may only use the
- * parse tree sometimes, then it may be best to call {@link #of(String)} to create the access
- * expression and then call {@link AccessExpression#parse()} when needed.
- *
- * @throws NullPointerException when the argument is null
- * @throws InvalidAccessExpressionException if the given expression is not valid
- */
- public static ParsedAccessExpression parse(String expression)
- throws InvalidAccessExpressionException {
- if (expression.isEmpty()) {
- return ParsedAccessExpressionImpl.EMPTY;
- }
- // Calling expression.getBytes(UTF8) will create a byte array that only this code has access to,
- // so not need to copy that byte array. That is why parse(byte[]) is not called here because
- // that would copy the array again.
- return ParsedAccessExpressionImpl.parseExpression(expression.getBytes(UTF_8));
- }
-
- /**
- * Quickly validates that an access expression is properly formed.
- *
- * @param expression a potential access expression that is expected to be encoded using UTF-8
- * @throws InvalidAccessExpressionException if the given expression is not valid
- * @throws NullPointerException when the argument is null
- */
- public static void validate(byte[] expression) throws InvalidAccessExpressionException {
- if (expression.length > 0) {
- Predicate<Tokenizer.AuthorizationToken> atp = authToken -> true;
- ParserEvaluator.parseAccessExpression(expression, atp, atp);
- } // else empty expression is valid, avoid object allocation
- }
-
- /**
- * @see #validate(byte[])
- */
- public static void validate(String expression) throws InvalidAccessExpressionException {
- if (!expression.isEmpty()) {
- validate(expression.getBytes(UTF_8));
- } // else empty expression is valid, avoid object allocation
- }
-
- /**
- * Validates and access expression and finds all authorizations in it passing them to the
- * authorizationConsumer. For example, for the expression {@code (A&B)|(A&C)|(A&D)}, this method
- * would pass {@code A,B,A,C,A,D} to the consumer one at a time. The function will conceptually
- * call {@link #unquote(String)} prior to passing an authorization to authorizationConsumer.
- *
- * <p>
- * What this method does could also be accomplished by creating a parse tree using
- * {@link AccessExpression#parse(String)} and then recursively walking the parse tree. The
- * implementation of this method does not create a parse tree and is much faster. If a parse tree
- * is already available, then it would likely be faster to use it rather than call this method.
- * </p>
- *
- * @throws InvalidAccessExpressionException when the expression is not valid.
- * @throws NullPointerException when any argument is null
- */
- public static void findAuthorizations(String expression, Consumer<String> authorizationConsumer)
- throws InvalidAccessExpressionException {
- findAuthorizations(expression.getBytes(UTF_8), authorizationConsumer);
- }
-
- /**
- * @see #findAuthorizations(String, Consumer)
- */
- public static void findAuthorizations(byte[] expression, Consumer<String> authorizationConsumer)
- throws InvalidAccessExpressionException {
- ParserEvaluator.findAuthorizations(expression, authorizationConsumer);
- }
-
- /**
- * Authorizations occurring in an access expression can only contain the characters listed in the
- * <a href=
- * "https://github.com/apache/accumulo-access/blob/main/SPECIFICATION.md">specification</a> unless
- * quoted (surrounded by quotation marks). Use this method to quote authorizations that occur in
- * an access expression. This method will only quote if it is needed.
- *
- * @throws NullPointerException when the argument is null
- */
- public static byte[] quote(byte[] term) {
- if (term.length == 0) {
- throw new IllegalArgumentException("Empty strings are not legal authorizations.");
- }
-
- boolean needsQuote = false;
-
- for (byte b : term) {
- if (!Tokenizer.isValidAuthChar(b)) {
- needsQuote = true;
- break;
- }
- }
-
- if (!needsQuote) {
- return term;
- }
-
- return AccessEvaluatorImpl.escape(term, true);
- }
-
- /**
- * Authorizations occurring in an access expression can only contain the characters listed in the
- * <a href=
- * "https://github.com/apache/accumulo-access/blob/main/SPECIFICATION.md">specification</a> unless
- * quoted (surrounded by quotation marks). Use this method to quote authorizations that occur in
- * an access expression. This method will only quote if it is needed.
- *
- * @throws NullPointerException when the argument is null
- */
- public static String quote(String term) {
- return new String(quote(term.getBytes(UTF_8)), UTF_8);
- }
-
- /**
- * Reverses what {@link #quote(String)} does, so will unquote and unescape an authorization if
- * needed. If the authorization is not quoted then it is returned as-is.
- *
- * @throws NullPointerException when the argument is null
- */
- public static String unquote(String term) {
- if (term.equals("\"\"") || term.isEmpty()) {
- throw new IllegalArgumentException("Empty strings are not legal authorizations.");
- }
-
- if (term.charAt(0) == '"' && term.charAt(term.length() - 1) == '"') {
- term = term.substring(1, term.length() - 1);
- return AccessEvaluatorImpl.unescape(new BytesWrapper(term.getBytes(UTF_8)));
- } else {
- return term;
- }
- }
}
diff --git a/core/src/main/java/org/apache/accumulo/access/AuthorizationValidator.java b/core/src/main/java/org/apache/accumulo/access/AuthorizationValidator.java
new file mode 100644
index 0000000..7baa907
--- /dev/null
+++ b/core/src/main/java/org/apache/accumulo/access/AuthorizationValidator.java
@@ -0,0 +1,115 @@
+/*
+ * 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
+ *
+ * https://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.accumulo.access;
+
+import java.nio.charset.CharsetDecoder;
+import java.util.function.BiPredicate;
+
+/**
+ * Implementations validate authorizations for Accumulo Access. Creating implementations that are
+ * stricter for a given domain can help avoid expressions that contain unexpected and unused
+ * authorizations.
+ *
+ * <p>
+ * When an authorization is quoted and/or escaped in access expression that is undone before is
+ * passed to this predicate. Conceptually it is like {@link Access#unquote(String)} is called prior
+ * to being passed to this predicate. If the authorization was quoted that information is passed
+ * along as it may be useful for optimizations.
+ *
+ * <p>
+ * A CharSequence is passed to this predicate for efficiency. It allows having a view into the
+ * larger expression at parse time without any memory allocations. It is not safe to keep a
+ * reference to the passed in char sequence as it is only stable while the predicate is called. If a
+ * reference needs to be kept for some side effect, then call {@code toString()} to allocate a copy.
+ * Avoiding calls to {@code toString()} will result in faster parsing.
+ * </p>
+ *
+ * @since 1.0.0
+ */
+public interface AuthorizationValidator
+ extends BiPredicate<CharSequence,AuthorizationValidator.AuthorizationCharacters> {
+
+ /**
+ * @since 1.0.0
+ */
+ enum AuthorizationCharacters {
+ /**
+ * This authorization could potentially contain any java character.
+ */
+ ANY,
+ /**
+ * Authorization only contains the characters
+ *
+ * <pre>{@code [0-9a-zA-Z_-.:/] }</pre>
+ */
+ BASIC
+ }
+
+ /**
+ * This is the default validator for Accumulo Access. It does the following check of characters in
+ * an authorization.
+ *
+ * <pre>
+ * {@code
+ * AuthorizationValidator DEFAULT = (auth, authChars) -> {
+ * if (authChars == AuthorizationCharacters.BASIC) {
+ * // The authorization is already known to only contain a small set of ASCII chars and no
+ * // further validation is needed.
+ * return true;
+ * }
+ *
+ * // Unsure what characters are present, so must validate them all.
+ * for (int i = 0; i < auth.length(); i++) {
+ * var c = auth.charAt(i);
+ * if (!Character.isDefined(c) || Character.isISOControl(c) || c == '\uFFFD') {
+ * return false;
+ * }
+ * }
+ * }
+ * }
+ * </pre>
+ *
+ * <p>
+ * The character U+FFFD is the Unicode replacement character and standard java libraries will
+ * insert this into strings when it has problem decoding UTF-8. Therefore, seeing this character
+ * likely means a java string was derived from corrupt or invalid UTF-8 data. This is why its
+ * considered invalid in an authorization by default.
+ *
+ * @see Character#isDefined(char)
+ * @see Character#isISOControl(char)
+ * @see CharsetDecoder#replacement()
+ * @since 1.0.0
+ */
+ AuthorizationValidator DEFAULT = (auth, authChars) -> {
+ if (authChars == AuthorizationCharacters.BASIC) {
+ // The authorization is already known to only contain a small set of ASCII chars and no
+ // further validation is needed.
+ return true;
+ }
+
+ // Unsure what characters are present, so must validate them all.
+ for (int i = 0; i < auth.length(); i++) {
+ var c = auth.charAt(i);
+ if (!Character.isDefined(c) || Character.isISOControl(c) || c == '\uFFFD') {
+ return false;
+ }
+ }
+ return true;
+ };
+}
diff --git a/core/src/main/java/org/apache/accumulo/access/Authorizations.java b/core/src/main/java/org/apache/accumulo/access/Authorizations.java
index 407b2eb..f3945d7 100644
--- a/core/src/main/java/org/apache/accumulo/access/Authorizations.java
+++ b/core/src/main/java/org/apache/accumulo/access/Authorizations.java
@@ -19,7 +19,6 @@
package org.apache.accumulo.access;
import java.io.Serializable;
-import java.util.Iterator;
import java.util.Set;
/**
@@ -28,75 +27,8 @@ import java.util.Set;
* <p>
* Instances of this class are thread-safe.
*
- * <p>
- * Note: The underlying implementation uses UTF-8 when converting between bytes and Strings.
- *
* @since 1.0.0
*/
-public final class Authorizations implements Iterable<String>, Serializable {
-
- private static final long serialVersionUID = 1L;
-
- private static final Authorizations EMPTY = new Authorizations(Set.of());
-
- private final Set<String> authorizations;
-
- private Authorizations(Set<String> authorizations) {
- this.authorizations = Set.copyOf(authorizations);
- }
-
- /**
- * Returns the set of authorization strings in this Authorization object
- *
- * @return immutable set of authorization strings
- */
- public Set<String> asSet() {
- return authorizations;
- }
-
- @Override
- public boolean equals(Object o) {
- if (o instanceof Authorizations) {
- var oa = (Authorizations) o;
- return authorizations.equals(oa.authorizations);
- }
-
- return false;
- }
-
- @Override
- public int hashCode() {
- return authorizations.hashCode();
- }
-
- @Override
- public String toString() {
- return authorizations.toString();
- }
-
- /**
- * @return a pre-allocated empty Authorizations object
- */
- public static Authorizations of() {
- return EMPTY;
- }
-
- /**
- * Creates an Authorizations object from the set of input authorization strings.
- *
- * @param authorizations set of authorization strings
- * @return Authorizations object
- */
- public static Authorizations of(Set<String> authorizations) {
- if (authorizations.isEmpty()) {
- return EMPTY;
- } else {
- return new Authorizations(authorizations);
- }
- }
-
- @Override
- public Iterator<String> iterator() {
- return authorizations.iterator();
- }
+public interface Authorizations extends Iterable<String>, Serializable {
+ Set<String> asSet();
}
diff --git a/core/src/main/java/org/apache/accumulo/access/InvalidAccessExpressionException.java b/core/src/main/java/org/apache/accumulo/access/InvalidAccessExpressionException.java
index 0119682..324ad95 100644
--- a/core/src/main/java/org/apache/accumulo/access/InvalidAccessExpressionException.java
+++ b/core/src/main/java/org/apache/accumulo/access/InvalidAccessExpressionException.java
@@ -21,11 +21,10 @@ package org.apache.accumulo.access;
import java.util.regex.PatternSyntaxException;
/**
- * An exception that is thrown when an access expression is not correct.
+ * An exception that is thrown when an access expression is not valid.
*
* @since 1.0.0
*/
-// TODO rename to illegal...
public final class InvalidAccessExpressionException extends IllegalArgumentException {
private static final long serialVersionUID = 1L;
diff --git a/core/src/main/java/org/apache/accumulo/access/InvalidAuthorizationException.java b/core/src/main/java/org/apache/accumulo/access/InvalidAuthorizationException.java
new file mode 100644
index 0000000..bd1ecca
--- /dev/null
+++ b/core/src/main/java/org/apache/accumulo/access/InvalidAuthorizationException.java
@@ -0,0 +1,28 @@
+/*
+ * 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
+ *
+ * https://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.accumulo.access;
+
+/**
+ * @since 1.0.0
+ */
+public class InvalidAuthorizationException extends RuntimeException {
+ public InvalidAuthorizationException(String auth) {
+ super("authorization : '" + auth + "'");
+ }
+}
diff --git a/core/src/main/java/org/apache/accumulo/access/ParsedAccessExpression.java b/core/src/main/java/org/apache/accumulo/access/ParsedAccessExpression.java
index 5928b1b..498df67 100644
--- a/core/src/main/java/org/apache/accumulo/access/ParsedAccessExpression.java
+++ b/core/src/main/java/org/apache/accumulo/access/ParsedAccessExpression.java
@@ -25,8 +25,8 @@ import org.apache.accumulo.access.impl.ParsedAccessExpressionImpl;
/**
* Instances of this class are immutable and wrap a verified access expression and a parse tree for
* the access expression. To create an instance of this class call
- * {@link AccessExpression#parse(String)}. The Accumulo Access project has examples that show how to
- * use the parse tree.
+ * {@link Access#newParsedExpression(String)}. The Accumulo Access project has examples that show
+ * how to use the parse tree.
*
* @since 1.0.0
*/
@@ -52,7 +52,7 @@ public sealed abstract class ParsedAccessExpression extends AccessExpression
/**
* Indicates an access expression is a single authorization. For this type
* {@link #getExpression()} will return the authorization in quoted and escaped form. Depending
- * on the use case {@link #unquote(String)} may need to be called.
+ * on the use case {@link Access#unquote(String)} may need to be called.
*/
AUTHORIZATION,
/**
diff --git a/core/src/main/java/org/apache/accumulo/access/impl/AccessEvaluatorImpl.java b/core/src/main/java/org/apache/accumulo/access/impl/AccessEvaluatorImpl.java
index d5189c2..6f34a69 100644
--- a/core/src/main/java/org/apache/accumulo/access/impl/AccessEvaluatorImpl.java
+++ b/core/src/main/java/org/apache/accumulo/access/impl/AccessEvaluatorImpl.java
@@ -18,11 +18,10 @@
*/
package org.apache.accumulo.access.impl;
-import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.apache.accumulo.access.impl.ByteUtils.BACKSLASH;
-import static org.apache.accumulo.access.impl.ByteUtils.QUOTE;
-import static org.apache.accumulo.access.impl.ByteUtils.isQuoteOrSlash;
-import static org.apache.accumulo.access.impl.ByteUtils.isQuoteSymbol;
+import static org.apache.accumulo.access.impl.CharUtils.BACKSLASH;
+import static org.apache.accumulo.access.impl.CharUtils.QUOTE;
+import static org.apache.accumulo.access.impl.CharUtils.isQuoteOrSlash;
+import static org.apache.accumulo.access.impl.CharUtils.isQuoteSymbol;
import java.util.HashSet;
import java.util.Set;
@@ -30,42 +29,54 @@ import java.util.function.Predicate;
import org.apache.accumulo.access.AccessEvaluator;
import org.apache.accumulo.access.AccessExpression;
+import org.apache.accumulo.access.AuthorizationValidator;
import org.apache.accumulo.access.Authorizations;
import org.apache.accumulo.access.InvalidAccessExpressionException;
public final class AccessEvaluatorImpl implements AccessEvaluator {
- private final Predicate<BytesWrapper> authorizedPredicate;
+ private final Predicate<CharSequence> authorizedPredicate;
+ private final AuthorizationValidator authorizationValidator;
/**
* Create an AccessEvaluatorImpl using an Authorizer object
*/
- public AccessEvaluatorImpl(Authorizer authorizationChecker) {
- this.authorizedPredicate = auth -> authorizationChecker.isAuthorized(unescape(auth));
+ public AccessEvaluatorImpl(Authorizer authorizationChecker,
+ AuthorizationValidator authorizationValidator) {
+ this.authorizedPredicate = auth -> authorizationChecker.isAuthorized(auth.toString());
+ this.authorizationValidator = authorizationValidator;
}
/**
* Create an AccessEvaluatorImpl using a collection of authorizations
*/
- public AccessEvaluatorImpl(Authorizations authorizations) {
+ public AccessEvaluatorImpl(Authorizations authorizations,
+ AuthorizationValidator authorizationValidator) {
var authsSet = authorizations.asSet();
- final Set<BytesWrapper> authBytes = new HashSet<>(authsSet.size());
+ final Set<CharsWrapper> wrappedAuths = new HashSet<>(authsSet.size());
for (String authorization : authsSet) {
- var auth = authorization.getBytes(UTF_8);
- if (auth.length == 0) {
+ if (authorization.isEmpty()) {
throw new IllegalArgumentException("Empty authorization");
}
- authBytes.add(new BytesWrapper(AccessEvaluatorImpl.escape(auth, false)));
+
+ wrappedAuths.add(new CharsWrapper(authorization.toCharArray()));
}
- authorizedPredicate = authBytes::contains;
+ this.authorizedPredicate = auth -> {
+ if (auth instanceof CharsWrapper) {
+ return wrappedAuths.contains(auth);
+ } else {
+ return wrappedAuths.contains(new CharsWrapper(auth.toString().toCharArray()));
+ }
+ };
+ this.authorizationValidator = authorizationValidator;
}
- public static String unescape(BytesWrapper auth) {
+ public static CharSequence unescape(CharSequence auth) {
int escapeCharCount = 0;
for (int i = 0; i < auth.length(); i++) {
- byte b = auth.byteAt(i);
- if (isQuoteOrSlash(b)) {
+ char c = auth.charAt(i);
+ if (isQuoteOrSlash(c)) {
escapeCharCount++;
}
}
@@ -75,28 +86,28 @@ public final class AccessEvaluatorImpl implements AccessEvaluator {
throw new IllegalArgumentException("Illegal escape sequence in auth : " + auth);
}
- byte[] unescapedCopy = new byte[auth.length() - escapeCharCount / 2];
+ char[] unescapedCopy = new char[auth.length() - escapeCharCount / 2];
int pos = 0;
for (int i = 0; i < auth.length(); i++) {
- byte b = auth.byteAt(i);
- if (b == BACKSLASH) {
+ char c = auth.charAt(i);
+ if (c == BACKSLASH) {
i++;
- b = auth.byteAt(i);
- if (!isQuoteOrSlash(b)) {
+ c = auth.charAt(i);
+ if (!isQuoteOrSlash(c)) {
throw new IllegalArgumentException("Illegal escape sequence in auth : " + auth);
}
- } else if (isQuoteSymbol(b)) {
+ } else if (isQuoteSymbol(c)) {
// should only see quote after a slash
throw new IllegalArgumentException(
"Illegal character after slash in auth String : " + auth);
}
- unescapedCopy[pos++] = b;
+ unescapedCopy[pos++] = c;
}
- return new String(unescapedCopy, UTF_8);
+ return new String(unescapedCopy);
} else {
- return auth.toString();
+ return auth;
}
}
@@ -107,23 +118,24 @@ public final class AccessEvaluatorImpl implements AccessEvaluator {
* @param shouldQuote true to wrap escaped authorization in quotes
* @return escaped authorization string
*/
- public static byte[] escape(byte[] auth, boolean shouldQuote) {
+ public static CharSequence escape(CharSequence auth, boolean shouldQuote) {
int escapeCount = 0;
- for (byte value : auth) {
- if (isQuoteOrSlash(value)) {
+ for (int i = 0; i < auth.length(); i++) {
+ if (isQuoteOrSlash(auth.charAt(i))) {
escapeCount++;
}
}
if (escapeCount > 0 || shouldQuote) {
- byte[] escapedAuth = new byte[auth.length + escapeCount + (shouldQuote ? 2 : 0)];
+ char[] escapedAuth = new char[auth.length() + escapeCount + (shouldQuote ? 2 : 0)];
int index = shouldQuote ? 1 : 0;
- for (byte b : auth) {
- if (isQuoteOrSlash(b)) {
+ for (int i = 0; i < auth.length(); i++) {
+ char c = auth.charAt(i);
+ if (isQuoteOrSlash(c)) {
escapedAuth[index++] = BACKSLASH;
}
- escapedAuth[index++] = b;
+ escapedAuth[index++] = c;
}
if (shouldQuote) {
@@ -131,7 +143,7 @@ public final class AccessEvaluatorImpl implements AccessEvaluator {
escapedAuth[escapedAuth.length - 1] = QUOTE;
}
- auth = escapedAuth;
+ auth = new String(escapedAuth);
}
return auth;
}
@@ -143,20 +155,21 @@ public final class AccessEvaluatorImpl implements AccessEvaluator {
@Override
public boolean canAccess(String expression) throws InvalidAccessExpressionException {
- return evaluate(expression.getBytes(UTF_8));
- }
-
- @Override
- public boolean canAccess(byte[] expression) throws InvalidAccessExpressionException {
return evaluate(expression);
}
- boolean evaluate(byte[] accessExpression) throws InvalidAccessExpressionException {
- var bytesWrapper = ParserEvaluator.lookupWrappers.get();
- Predicate<Tokenizer.AuthorizationToken> atp = authToken -> {
- bytesWrapper.set(authToken.data, authToken.start, authToken.len);
- return authorizedPredicate.test(bytesWrapper);
+ boolean evaluate(String accessExpression) throws InvalidAccessExpressionException {
+ var charsWrapper = ParserEvaluator.lookupWrappers.get();
+ Predicate<Tokenizer.AuthorizationToken> atp = authToken -> authorizedPredicate
+ .test(ParserEvaluator.validateAuth(authorizationValidator, authToken, charsWrapper));
+
+ // This is used once the expression is known to always be true or false. For this case only need
+ // to validate authorizations, do not need to look them up in a set.
+ Predicate<Tokenizer.AuthorizationToken> shortCircuit = authToken -> {
+ ParserEvaluator.validateAuth(authorizationValidator, authToken, charsWrapper);
+ return true;
};
- return ParserEvaluator.parseAccessExpression(accessExpression, atp, authToken -> true);
+
+ return ParserEvaluator.parseAccessExpression(accessExpression, atp, shortCircuit);
}
}
diff --git a/core/src/main/java/org/apache/accumulo/access/impl/AccessExpressionImpl.java b/core/src/main/java/org/apache/accumulo/access/impl/AccessExpressionImpl.java
index 9f60e33..da611b6 100644
--- a/core/src/main/java/org/apache/accumulo/access/impl/AccessExpressionImpl.java
+++ b/core/src/main/java/org/apache/accumulo/access/impl/AccessExpressionImpl.java
@@ -18,8 +18,6 @@
*/
package org.apache.accumulo.access.impl;
-import static java.nio.charset.StandardCharsets.UTF_8;
-
import java.util.concurrent.atomic.AtomicReference;
import org.apache.accumulo.access.AccessExpression;
@@ -34,15 +32,9 @@ public final class AccessExpressionImpl extends AccessExpression {
private final AtomicReference<ParsedAccessExpression> parseTreeRef = new AtomicReference<>();
public AccessExpressionImpl(String expression) {
- validate(expression);
this.expression = expression;
}
- public AccessExpressionImpl(byte[] expression) {
- validate(expression);
- this.expression = new String(expression, UTF_8);
- }
-
@Override
public String getExpression() {
return expression;
@@ -52,12 +44,48 @@ public final class AccessExpressionImpl extends AccessExpression {
public ParsedAccessExpression parse() {
ParsedAccessExpression parseTree = parseTreeRef.get();
if (parseTree == null) {
+ // This expression authorizations were already validated, so can pass a lambda that always
+ // returns true
parseTreeRef.compareAndSet(null,
- ParsedAccessExpressionImpl.parseExpression(expression.getBytes(UTF_8)));
+ ParsedAccessExpressionImpl.parseExpression(expression, (auth, quoting) -> true));
// must get() again in case another thread won w/ the compare and set, this ensures this
// method always returns the exact same object
parseTree = parseTreeRef.get();
}
return parseTree;
}
+
+ public static CharSequence quote(CharSequence term) {
+ if (term.isEmpty()) {
+ throw new IllegalArgumentException("Empty strings are not legal authorizations.");
+ }
+
+ boolean needsQuote = false;
+
+ for (int i = 0; i < term.length(); i++) {
+ if (!Tokenizer.isValidAuthChar(term.charAt(i))) {
+ needsQuote = true;
+ break;
+ }
+ }
+
+ if (!needsQuote) {
+ return term;
+ }
+
+ return AccessEvaluatorImpl.escape(term, true);
+ }
+
+ public static CharSequence unquote(CharSequence term) {
+ if (term.equals("\"\"") || term.isEmpty()) {
+ throw new IllegalArgumentException("Empty strings are not legal authorizations.");
+ }
+
+ if (term.charAt(0) == '"' && term.charAt(term.length() - 1) == '"') {
+ term = term.subSequence(1, term.length() - 1);
+ return AccessEvaluatorImpl.unescape(term);
+ } else {
+ return term;
+ }
+ }
}
diff --git a/core/src/main/java/org/apache/accumulo/access/impl/AccessImpl.java b/core/src/main/java/org/apache/accumulo/access/impl/AccessImpl.java
new file mode 100644
index 0000000..d8b1d57
--- /dev/null
+++ b/core/src/main/java/org/apache/accumulo/access/impl/AccessImpl.java
@@ -0,0 +1,117 @@
+/*
+ * 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
+ *
+ * https://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.accumulo.access.impl;
+
+import static org.apache.accumulo.access.AuthorizationValidator.AuthorizationCharacters.ANY;
+
+import java.util.Collection;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Consumer;
+
+import org.apache.accumulo.access.Access;
+import org.apache.accumulo.access.AccessEvaluator;
+import org.apache.accumulo.access.AccessExpression;
+import org.apache.accumulo.access.AuthorizationValidator;
+import org.apache.accumulo.access.Authorizations;
+import org.apache.accumulo.access.InvalidAccessExpressionException;
+import org.apache.accumulo.access.InvalidAuthorizationException;
+import org.apache.accumulo.access.ParsedAccessExpression;
+
+public class AccessImpl implements Access {
+
+ private final AuthorizationValidator authValidator;
+
+ private void validateAuthorization(CharSequence auth,
+ AuthorizationValidator.AuthorizationCharacters quoting) {
+ if (auth.isEmpty()) {
+ throw new IllegalArgumentException("Empty string is not a valid authorization");
+ }
+ if (!authValidator.test(auth, quoting)) {
+ throw new InvalidAuthorizationException(auth.toString());
+ }
+ }
+
+ public AccessImpl(AuthorizationValidator authValidator) {
+ this.authValidator = Objects.requireNonNull(authValidator);
+ }
+
+ @Override
+ public AccessExpression newExpression(String expression) {
+ if (expression.isEmpty()) {
+ return AccessExpressionImpl.EMPTY;
+ }
+ validateExpression(expression);
+ return new AccessExpressionImpl(expression);
+ }
+
+ @Override
+ public ParsedAccessExpression newParsedExpression(String expression) {
+ return ParsedAccessExpressionImpl.parseExpression(expression, authValidator);
+ }
+
+ @Override
+ public Authorizations newAuthorizations(Set<String> authorizations) {
+ if (authorizations.isEmpty()) {
+ return AuthorizationsImpl.EMPTY;
+ } else {
+ authorizations.forEach(auth -> validateAuthorization(auth, ANY));
+ return new AuthorizationsImpl(authorizations);
+ }
+ }
+
+ @Override
+ public void findAuthorizations(String expression, Consumer<String> authorizationConsumer)
+ throws InvalidAccessExpressionException {
+ ParserEvaluator.findAuthorizations(expression, authorizationConsumer, authValidator);
+ }
+
+ @Override
+ public String quote(String authorization) {
+ validateAuthorization(authorization, ANY);
+ return AccessExpressionImpl.quote(authorization).toString();
+ }
+
+ @Override
+ public String unquote(String authorization) {
+ var unquoted = AccessExpressionImpl.unquote(authorization);
+ validateAuthorization(unquoted, ANY);
+ return unquoted.toString();
+ }
+
+ @Override
+ public void validateExpression(String expression) throws InvalidAccessExpressionException {
+ ParserEvaluator.validate(expression, authValidator);
+ }
+
+ @Override
+ public AccessEvaluator newEvaluator(Authorizations authorizations) {
+ return new AccessEvaluatorImpl(authorizations, authValidator);
+ }
+
+ @Override
+ public AccessEvaluator newEvaluator(AccessEvaluator.Authorizer authorizer) {
+ return new AccessEvaluatorImpl(authorizer, authValidator);
+ }
+
+ @Override
+ public AccessEvaluator newEvaluator(Collection<Authorizations> authorizationSets) {
+ return new MultiAccessEvaluatorImpl(authorizationSets, authValidator);
+ }
+}
diff --git a/core/src/main/java/org/apache/accumulo/access/impl/AuthorizationsImpl.java b/core/src/main/java/org/apache/accumulo/access/impl/AuthorizationsImpl.java
new file mode 100644
index 0000000..6ad1d46
--- /dev/null
+++ b/core/src/main/java/org/apache/accumulo/access/impl/AuthorizationsImpl.java
@@ -0,0 +1,52 @@
+/*
+ * 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
+ *
+ * https://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.accumulo.access.impl;
+
+import java.io.Serial;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.apache.accumulo.access.Authorizations;
+
+public record AuthorizationsImpl(Set<String> authorizations) implements Authorizations {
+
+ @Serial
+ private static final long serialVersionUID = 1L;
+
+ static final Authorizations EMPTY = new AuthorizationsImpl(Set.of());
+
+ public AuthorizationsImpl(Set<String> authorizations) {
+ this.authorizations = Set.copyOf(authorizations);
+ }
+
+ /**
+ * Returns the set of authorization strings in this Authorization object
+ *
+ * @return immutable set of authorization strings
+ */
+ @Override
+ public Set<String> asSet() {
+ return authorizations;
+ }
+
+ @Override
+ public Iterator<String> iterator() {
+ return authorizations.iterator();
+ }
+}
diff --git a/core/src/main/java/org/apache/accumulo/access/impl/BuilderImpl.java b/core/src/main/java/org/apache/accumulo/access/impl/BuilderImpl.java
new file mode 100644
index 0000000..7e8fc88
--- /dev/null
+++ b/core/src/main/java/org/apache/accumulo/access/impl/BuilderImpl.java
@@ -0,0 +1,40 @@
+/*
+ * 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
+ *
+ * https://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.accumulo.access.impl;
+
+import java.util.Objects;
+
+import org.apache.accumulo.access.Access;
+import org.apache.accumulo.access.AuthorizationValidator;
+
+public class BuilderImpl implements Access.Builder {
+
+ private AuthorizationValidator validator;
+
+ @Override
+ public Access.Builder authorizationValidator(AuthorizationValidator validator) {
+ this.validator = Objects.requireNonNull(validator);
+ return this;
+ }
+
+ @Override
+ public Access build() {
+ return new AccessImpl(validator == null ? AuthorizationValidator.DEFAULT : validator);
+ }
+}
diff --git a/core/src/main/java/org/apache/accumulo/access/impl/ByteUtils.java b/core/src/main/java/org/apache/accumulo/access/impl/CharUtils.java
similarity index 72%
rename from core/src/main/java/org/apache/accumulo/access/impl/ByteUtils.java
rename to core/src/main/java/org/apache/accumulo/access/impl/CharUtils.java
index 8f3c209..696fbb1 100644
--- a/core/src/main/java/org/apache/accumulo/access/impl/ByteUtils.java
+++ b/core/src/main/java/org/apache/accumulo/access/impl/CharUtils.java
@@ -22,37 +22,37 @@ package org.apache.accumulo.access.impl;
* This class exists to avoid repeat conversions from byte to char as well as to provide helper
* methods for comparing them.
*/
-final class ByteUtils {
- static final byte QUOTE = (byte) '"';
- static final byte BACKSLASH = (byte) '\\';
- static final byte AND_OPERATOR = (byte) '&';
- static final byte OR_OPERATOR = (byte) '|';
+final class CharUtils {
+ static final char QUOTE = '"';
+ static final char BACKSLASH = '\\';
+ static final char AND_OPERATOR = '&';
+ static final char OR_OPERATOR = '|';
- private ByteUtils() {
+ private CharUtils() {
// private constructor to prevent instantiation
}
- static boolean isQuoteSymbol(byte b) {
+ static boolean isQuoteSymbol(char b) {
return b == QUOTE;
}
- static boolean isBackslashSymbol(byte b) {
+ static boolean isBackslashSymbol(char b) {
return b == BACKSLASH;
}
- static boolean isQuoteOrSlash(byte b) {
+ static boolean isQuoteOrSlash(char b) {
return isQuoteSymbol(b) || isBackslashSymbol(b);
}
- static boolean isAndOperator(byte b) {
+ static boolean isAndOperator(char b) {
return b == AND_OPERATOR;
}
- static boolean isOrOperator(byte b) {
+ static boolean isOrOperator(char b) {
return b == OR_OPERATOR;
}
- static boolean isAndOrOperator(byte b) {
+ static boolean isAndOrOperator(char b) {
return isAndOperator(b) || isOrOperator(b);
}
}
diff --git a/core/src/main/java/org/apache/accumulo/access/impl/BytesWrapper.java b/core/src/main/java/org/apache/accumulo/access/impl/CharsWrapper.java
similarity index 51%
rename from core/src/main/java/org/apache/accumulo/access/impl/BytesWrapper.java
rename to core/src/main/java/org/apache/accumulo/access/impl/CharsWrapper.java
index e034f70..4085aff 100644
--- a/core/src/main/java/org/apache/accumulo/access/impl/BytesWrapper.java
+++ b/core/src/main/java/org/apache/accumulo/access/impl/CharsWrapper.java
@@ -18,46 +18,59 @@
*/
package org.apache.accumulo.access.impl;
-import static java.nio.charset.StandardCharsets.UTF_8;
-import static java.util.Objects.checkFromIndexSize;
-import static java.util.Objects.checkIndex;
-
import java.util.Arrays;
+import java.util.Objects;
-public final class BytesWrapper implements Comparable<BytesWrapper> {
-
- private byte[] data;
+public final class CharsWrapper implements CharSequence {
+ private char[] wrapped;
private int offset;
- private int length;
-
- /**
- * Creates a new sequence. The given byte array is used directly as the backing array, so later
- * changes made to the array reflect into the new sequence.
- *
- * @param data byte data
- */
- public BytesWrapper(byte[] data) {
- set(data, 0, data.length);
+ private int len;
+
+ CharsWrapper(char[] wrapped) {
+ this.wrapped = wrapped;
+ this.offset = 0;
+ this.len = this.wrapped.length;
}
- public byte byteAt(int i) {
- return data[offset + checkIndex(i, length)];
+ private CharsWrapper(char[] wrapped, int offset, int len) {
+ this.wrapped = wrapped;
+ this.offset = offset;
+ this.len = len;
}
+ @Override
public int length() {
- return length;
+ return len;
}
@Override
- public int compareTo(BytesWrapper obs) {
- return Arrays.compare(data, offset, offset + length(), obs.data, obs.offset,
- obs.offset + obs.length());
+ public char charAt(int index) {
+ Objects.checkIndex(index, len);
+ return wrapped[offset + index];
+ }
+
+ @Override
+ public CharSequence subSequence(int start, int end) {
+ Objects.checkFromToIndex(start, end, len);
+ return new CharsWrapper(wrapped, start + offset, end - start);
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = 1;
+
+ int end = offset + length();
+ for (int i = offset; i < end; i++) {
+ hash = (31 * hash) + wrapped[i];
+ }
+
+ return hash;
}
@Override
public boolean equals(Object o) {
- if (o instanceof BytesWrapper) {
- BytesWrapper obs = (BytesWrapper) o;
+ if (o instanceof CharsWrapper) {
+ CharsWrapper obs = (CharsWrapper) o;
if (this == o) {
return true;
@@ -67,39 +80,21 @@ public final class BytesWrapper implements Comparable<BytesWrapper> {
return false;
}
- return compareTo(obs) == 0;
+ return Arrays.equals(wrapped, offset, offset + len, obs.wrapped, obs.offset,
+ obs.offset + obs.len);
}
return false;
-
- }
-
- @Override
- public int hashCode() {
- int hash = 1;
-
- int end = offset + length();
- for (int i = offset; i < end; i++) {
- hash = (31 * hash) + data[i];
- }
-
- return hash;
}
@Override
public String toString() {
- return new String(data, offset, length, UTF_8);
+ return new String(wrapped, offset, len);
}
- /*
- * Wraps the given byte[] and captures the current offset and length. This method does *not* make
- * a copy of the input buffer
- */
- void set(byte[] data, int offset, int length) {
- checkFromIndexSize(offset, length, data.length);
- this.data = data;
- this.offset = offset;
- this.length = length;
+ public void set(char[] data, int start, int len) {
+ this.wrapped = data;
+ this.offset = start;
+ this.len = len;
}
-
}
diff --git a/core/src/main/java/org/apache/accumulo/access/impl/MultiAccessEvaluatorImpl.java b/core/src/main/java/org/apache/accumulo/access/impl/MultiAccessEvaluatorImpl.java
index 8c268f8..e2a905c 100644
--- a/core/src/main/java/org/apache/accumulo/access/impl/MultiAccessEvaluatorImpl.java
+++ b/core/src/main/java/org/apache/accumulo/access/impl/MultiAccessEvaluatorImpl.java
@@ -18,39 +18,30 @@
*/
package org.apache.accumulo.access.impl;
-import static java.nio.charset.StandardCharsets.UTF_8;
-
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.apache.accumulo.access.AccessEvaluator;
import org.apache.accumulo.access.AccessExpression;
+import org.apache.accumulo.access.AuthorizationValidator;
import org.apache.accumulo.access.Authorizations;
import org.apache.accumulo.access.InvalidAccessExpressionException;
public final class MultiAccessEvaluatorImpl implements AccessEvaluator {
- public static AccessEvaluator of(Collection<Authorizations> authorizationSets) {
- return new MultiAccessEvaluatorImpl(authorizationSets);
- }
-
private final List<AccessEvaluator> evaluators;
- private MultiAccessEvaluatorImpl(Collection<Authorizations> authorizationSets) {
+ MultiAccessEvaluatorImpl(Collection<Authorizations> authorizationSets,
+ AuthorizationValidator validator) {
evaluators = new ArrayList<>(authorizationSets.size());
for (Authorizations authorizations : authorizationSets) {
- evaluators.add(new AccessEvaluatorImpl(authorizations));
+ evaluators.add(new AccessEvaluatorImpl(authorizations, validator));
}
}
@Override
public boolean canAccess(String accessExpression) throws InvalidAccessExpressionException {
- return canAccess(accessExpression.getBytes(UTF_8));
- }
-
- @Override
- public boolean canAccess(byte[] accessExpression) throws InvalidAccessExpressionException {
for (AccessEvaluator evaluator : evaluators) {
if (!evaluator.canAccess(accessExpression)) {
return false;
diff --git a/core/src/main/java/org/apache/accumulo/access/impl/ParsedAccessExpressionImpl.java b/core/src/main/java/org/apache/accumulo/access/impl/ParsedAccessExpressionImpl.java
index 99f6464..4f97f32 100644
--- a/core/src/main/java/org/apache/accumulo/access/impl/ParsedAccessExpressionImpl.java
+++ b/core/src/main/java/org/apache/accumulo/access/impl/ParsedAccessExpressionImpl.java
@@ -18,36 +18,36 @@
*/
package org.apache.accumulo.access.impl;
-import static java.nio.charset.StandardCharsets.UTF_8;
import static org.apache.accumulo.access.ParsedAccessExpression.ExpressionType.AND;
import static org.apache.accumulo.access.ParsedAccessExpression.ExpressionType.AUTHORIZATION;
import static org.apache.accumulo.access.ParsedAccessExpression.ExpressionType.OR;
-import static org.apache.accumulo.access.impl.ByteUtils.AND_OPERATOR;
-import static org.apache.accumulo.access.impl.ByteUtils.OR_OPERATOR;
-import static org.apache.accumulo.access.impl.ByteUtils.isAndOrOperator;
+import static org.apache.accumulo.access.impl.CharUtils.AND_OPERATOR;
+import static org.apache.accumulo.access.impl.CharUtils.OR_OPERATOR;
+import static org.apache.accumulo.access.impl.CharUtils.isAndOrOperator;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
+import org.apache.accumulo.access.AuthorizationValidator;
+import org.apache.accumulo.access.InvalidAuthorizationException;
import org.apache.accumulo.access.ParsedAccessExpression;
public final class ParsedAccessExpressionImpl extends ParsedAccessExpression {
private static final long serialVersionUID = 1L;
- private final byte[] expression;
+ private final String wholeExpression;
+ private final AtomicReference<String> expression = new AtomicReference<>(null);
private final int offset;
private final int length;
private final ExpressionType type;
private final List<ParsedAccessExpression> children;
- private final AtomicReference<String> stringExpression = new AtomicReference<>(null);
-
public static final ParsedAccessExpression EMPTY = new ParsedAccessExpressionImpl();
- private ParsedAccessExpressionImpl(byte operator, byte[] expression, int offset, int length,
+ private ParsedAccessExpressionImpl(char operator, String wholeExpression, int offset, int length,
List<ParsedAccessExpression> children) {
if (children.isEmpty()) {
throw new IllegalArgumentException("Must have children with an operator");
@@ -61,15 +61,15 @@ public final class ParsedAccessExpressionImpl extends ParsedAccessExpression {
this.type = OR;
}
- this.expression = expression;
+ this.wholeExpression = wholeExpression;
this.offset = offset;
this.length = length;
this.children = List.copyOf(children);
}
- private ParsedAccessExpressionImpl(byte[] expression, int offset, int length) {
+ private ParsedAccessExpressionImpl(String wholeExpression, int offset, int length) {
this.type = AUTHORIZATION;
- this.expression = expression;
+ this.wholeExpression = wholeExpression;
this.offset = offset;
this.length = length;
this.children = List.of();
@@ -77,21 +77,21 @@ public final class ParsedAccessExpressionImpl extends ParsedAccessExpression {
ParsedAccessExpressionImpl() {
this.type = ExpressionType.EMPTY;
+ this.wholeExpression = "";
this.offset = 0;
this.length = 0;
- this.expression = new byte[0];
this.children = List.of();
}
@Override
public String getExpression() {
- String strExp = stringExpression.get();
+ String strExp = expression.get();
if (strExp != null) {
return strExp;
}
- strExp = new String(expression, offset, length, UTF_8);
- stringExpression.compareAndSet(null, strExp);
- return stringExpression.get();
+ strExp = wholeExpression.substring(offset, length + offset);
+ expression.compareAndSet(null, strExp);
+ return expression.get();
}
@Override
@@ -109,27 +109,30 @@ public final class ParsedAccessExpressionImpl extends ParsedAccessExpression {
return children;
}
- public static ParsedAccessExpression parseExpression(byte[] expression) {
- if (expression.length == 0) {
+ public static ParsedAccessExpression parseExpression(String expression,
+ AuthorizationValidator authorizationValidator) {
+ if (expression.isEmpty()) {
return ParsedAccessExpressionImpl.EMPTY;
}
- Tokenizer tokenizer = new Tokenizer(expression);
- var parsed = ParsedAccessExpressionImpl.parseExpression(tokenizer, false);
+ Tokenizer tokenizer = ParserEvaluator.getPerThreadTokenizer(expression);
+ var parsed =
+ ParsedAccessExpressionImpl.parseExpression(tokenizer, expression, authorizationValidator);
if (tokenizer.hasNext()) {
// not all input was read, so not a valid expression
- tokenizer.error("Unexpected character '" + (char) tokenizer.peek() + "'");
+ tokenizer.error("Unexpected character '" + tokenizer.peek() + "'");
}
return parsed;
}
private static ParsedAccessExpressionImpl parseExpression(Tokenizer tokenizer,
- boolean wrappedWithParens) {
+ String wholeExpression, AuthorizationValidator authorizationValidator) {
int beginOffset = tokenizer.curentOffset();
- ParsedAccessExpressionImpl node = parseParenExpressionOrAuthorization(tokenizer);
+ ParsedAccessExpressionImpl node =
+ parseParenExpressionOrAuthorization(tokenizer, wholeExpression, authorizationValidator);
if (tokenizer.hasNext()) {
var operator = tokenizer.peek();
@@ -138,7 +141,8 @@ public final class ParsedAccessExpressionImpl extends ParsedAccessExpression {
nodes.add(node);
do {
tokenizer.advance();
- ParsedAccessExpression next = parseParenExpressionOrAuthorization(tokenizer);
+ ParsedAccessExpression next = parseParenExpressionOrAuthorization(tokenizer,
+ wholeExpression, authorizationValidator);
nodes.add(next);
} while (tokenizer.hasNext() && tokenizer.peek() == operator);
@@ -149,7 +153,7 @@ public final class ParsedAccessExpressionImpl extends ParsedAccessExpression {
int endOffset = tokenizer.curentOffset();
- node = new ParsedAccessExpressionImpl(operator, tokenizer.expression(), beginOffset,
+ node = new ParsedAccessExpressionImpl(operator, wholeExpression, beginOffset,
endOffset - beginOffset, nodes);
}
}
@@ -157,8 +161,8 @@ public final class ParsedAccessExpressionImpl extends ParsedAccessExpression {
return node;
}
- private static ParsedAccessExpressionImpl
- parseParenExpressionOrAuthorization(Tokenizer tokenizer) {
+ private static ParsedAccessExpressionImpl parseParenExpressionOrAuthorization(Tokenizer tokenizer,
+ String wholeExpression, AuthorizationValidator authorizationValidator) {
if (!tokenizer.hasNext()) {
tokenizer
.error("Expected a '(' character or an authorization token instead saw end of input");
@@ -166,12 +170,31 @@ public final class ParsedAccessExpressionImpl extends ParsedAccessExpression {
if (tokenizer.peek() == ParserEvaluator.OPEN_PAREN) {
tokenizer.advance();
- var node = parseExpression(tokenizer, true);
+ var node = parseExpression(tokenizer, wholeExpression, authorizationValidator);
tokenizer.next(ParserEvaluator.CLOSE_PAREN);
return node;
} else {
var auth = tokenizer.nextAuthorization(true);
- return new ParsedAccessExpressionImpl(auth.data, auth.start, auth.len);
+ CharSequence unquotedAuth;
+ AuthorizationValidator.AuthorizationCharacters quoting;
+ var wrapper = ParserEvaluator.lookupWrappers.get();
+ if (CharUtils.isQuoteSymbol(auth.data[auth.start])) {
+ wrapper.set(auth.data, auth.start + 1, auth.len - 2);
+ if (auth.hasEscapes) {
+ unquotedAuth = AccessEvaluatorImpl.unescape(wrapper);
+ } else {
+ unquotedAuth = wrapper;
+ }
+ quoting = AuthorizationValidator.AuthorizationCharacters.ANY;
+ } else {
+ wrapper.set(auth.data, auth.start, auth.len);
+ unquotedAuth = wrapper;
+ quoting = AuthorizationValidator.AuthorizationCharacters.BASIC;
+ }
+ if (!authorizationValidator.test(unquotedAuth, quoting)) {
+ throw new InvalidAuthorizationException(unquotedAuth.toString());
+ }
+ return new ParsedAccessExpressionImpl(wholeExpression, auth.start, auth.len);
}
}
}
diff --git a/core/src/main/java/org/apache/accumulo/access/impl/ParserEvaluator.java b/core/src/main/java/org/apache/accumulo/access/impl/ParserEvaluator.java
index 2df624c..557d89a 100644
--- a/core/src/main/java/org/apache/accumulo/access/impl/ParserEvaluator.java
+++ b/core/src/main/java/org/apache/accumulo/access/impl/ParserEvaluator.java
@@ -18,44 +18,90 @@
*/
package org.apache.accumulo.access.impl;
-import static org.apache.accumulo.access.impl.ByteUtils.isAndOrOperator;
+import static org.apache.accumulo.access.impl.CharUtils.isAndOrOperator;
import java.util.function.Consumer;
import java.util.function.Predicate;
+import org.apache.accumulo.access.AuthorizationValidator;
import org.apache.accumulo.access.InvalidAccessExpressionException;
+import org.apache.accumulo.access.InvalidAuthorizationException;
/**
* Code for parsing and evaluating an access expression at the same time.
*/
public final class ParserEvaluator {
- static final byte OPEN_PAREN = (byte) '(';
- static final byte CLOSE_PAREN = (byte) ')';
+ static final char OPEN_PAREN = '(';
+ static final char CLOSE_PAREN = ')';
- private static final byte[] EMPTY = new byte[0];
+ static final ThreadLocal<CharsWrapper> lookupWrappers =
+ ThreadLocal.withInitial(() -> new CharsWrapper(new char[0]));
+ static final ThreadLocal<Tokenizer> tokenizers =
+ ThreadLocal.withInitial(() -> new Tokenizer(new char[0]));
+ static final ThreadLocal<char[]> expressionArrays = ThreadLocal.withInitial(() -> new char[128]);
- static final ThreadLocal<BytesWrapper> lookupWrappers =
- ThreadLocal.withInitial(() -> new BytesWrapper(EMPTY));
- private static final ThreadLocal<Tokenizer> tokenizers =
- ThreadLocal.withInitial(() -> new Tokenizer(EMPTY));
+ static Tokenizer getPerThreadTokenizer(String expression) {
+ var tokenizer = tokenizers.get();
+ var array = expressionArrays.get();
+ if (array.length < expression.length()) {
+ int newLen = array.length;
+ while (newLen < expression.length()) {
+ newLen = Math.multiplyExact(newLen, 2);
+ }
+ array = new char[newLen];
+ expressionArrays.set(array);
+ }
+ expression.getChars(0, expression.length(), array, 0);
+ tokenizer.reset(array, expression.length());
+
+ return tokenizer;
+ }
+
+ static CharSequence validateAuth(AuthorizationValidator authValidator,
+ Tokenizer.AuthorizationToken authToken, CharsWrapper charsWrapper) {
+ charsWrapper.set(authToken.data, authToken.start, authToken.len);
+ CharSequence authorizations;
+ if (authToken.hasEscapes) {
+ authorizations = AccessEvaluatorImpl.unescape(charsWrapper);
+ } else {
+ authorizations = charsWrapper;
+ }
+ if (!authValidator.test(authorizations, authToken.quoting)) {
+ throw new InvalidAuthorizationException(authorizations.toString());
+ }
+ return authorizations;
+ }
- public static void findAuthorizations(byte[] expression, Consumer<String> authorizationConsumer)
+ public static void validate(String expression, AuthorizationValidator authValidator)
throws InvalidAccessExpressionException {
- var bytesWrapper = ParserEvaluator.lookupWrappers.get();
+ if (expression.isEmpty()) {
+ return;
+ }
+
+ var charsWrapper = ParserEvaluator.lookupWrappers.get();
+ Predicate<Tokenizer.AuthorizationToken> vp = authToken -> {
+ validateAuth(authValidator, authToken, charsWrapper);
+ return true;
+ };
+
+ ParserEvaluator.parseAccessExpression(expression, vp, vp);
+ }
+
+ public static void findAuthorizations(String expression, Consumer<String> authorizationConsumer,
+ AuthorizationValidator authValidator) throws InvalidAccessExpressionException {
+ var charsWrapper = ParserEvaluator.lookupWrappers.get();
Predicate<Tokenizer.AuthorizationToken> atp = authToken -> {
- bytesWrapper.set(authToken.data, authToken.start, authToken.len);
- authorizationConsumer.accept(AccessEvaluatorImpl.unescape(bytesWrapper));
+ authorizationConsumer.accept(validateAuth(authValidator, authToken, charsWrapper).toString());
return true;
};
ParserEvaluator.parseAccessExpression(expression, atp, atp);
}
- public static boolean parseAccessExpression(byte[] expression,
+ public static boolean parseAccessExpression(String expression,
Predicate<Tokenizer.AuthorizationToken> authorizedPredicate,
Predicate<Tokenizer.AuthorizationToken> shortCircuitPredicate) {
- var tokenizer = tokenizers.get();
- tokenizer.reset(expression);
+ var tokenizer = getPerThreadTokenizer(expression);
return parseAccessExpression(tokenizer, authorizedPredicate, shortCircuitPredicate);
}
@@ -71,7 +117,7 @@ public final class ParserEvaluator {
if (tokenizer.hasNext()) {
// not all input was read, so not a valid expression
- tokenizer.error("Unexpected character '" + (char) tokenizer.peek() + "'");
+ tokenizer.error("Unexpected character '" + tokenizer.peek() + "'");
}
return node;
@@ -86,13 +132,13 @@ public final class ParserEvaluator {
if (tokenizer.hasNext()) {
var operator = tokenizer.peek();
- if (operator == ByteUtils.AND_OPERATOR) {
+ if (operator == CharUtils.AND_OPERATOR) {
result = parseAndExpression(result, tokenizer, authorizedPredicate, shortCircuitPredicate);
if (tokenizer.hasNext() && isAndOrOperator(tokenizer.peek())) {
// A case of mixed operators, lets give a clear error message
tokenizer.error("Cannot mix '|' and '&'");
}
- } else if (operator == ByteUtils.OR_OPERATOR) {
+ } else if (operator == CharUtils.OR_OPERATOR) {
result = parseOrExpression(result, tokenizer, authorizedPredicate, shortCircuitPredicate);
if (tokenizer.hasNext() && isAndOrOperator(tokenizer.peek())) {
// A case of mixed operators, lets give a clear error message
@@ -117,7 +163,7 @@ public final class ParserEvaluator {
var nextResult = parseParenExpressionOrAuthorization(tokenizer, authorizedPredicate,
shortCircuitPredicate);
result &= nextResult;
- } while (tokenizer.hasNext() && tokenizer.peek() == ByteUtils.AND_OPERATOR);
+ } while (tokenizer.hasNext() && tokenizer.peek() == CharUtils.AND_OPERATOR);
return result;
}
@@ -134,7 +180,7 @@ public final class ParserEvaluator {
var nextResult = parseParenExpressionOrAuthorization(tokenizer, authorizedPredicate,
shortCircuitPredicate);
result |= nextResult;
- } while (tokenizer.hasNext() && tokenizer.peek() == ByteUtils.OR_OPERATOR);
+ } while (tokenizer.hasNext() && tokenizer.peek() == CharUtils.OR_OPERATOR);
return result;
}
diff --git a/core/src/main/java/org/apache/accumulo/access/impl/Tokenizer.java b/core/src/main/java/org/apache/accumulo/access/impl/Tokenizer.java
index da5b6ab..6b46f35 100644
--- a/core/src/main/java/org/apache/accumulo/access/impl/Tokenizer.java
+++ b/core/src/main/java/org/apache/accumulo/access/impl/Tokenizer.java
@@ -18,13 +18,13 @@
*/
package org.apache.accumulo.access.impl;
-import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.apache.accumulo.access.impl.ByteUtils.isBackslashSymbol;
-import static org.apache.accumulo.access.impl.ByteUtils.isQuoteOrSlash;
-import static org.apache.accumulo.access.impl.ByteUtils.isQuoteSymbol;
+import static org.apache.accumulo.access.impl.CharUtils.isBackslashSymbol;
+import static org.apache.accumulo.access.impl.CharUtils.isQuoteOrSlash;
+import static org.apache.accumulo.access.impl.CharUtils.isQuoteSymbol;
import java.util.stream.IntStream;
+import org.apache.accumulo.access.AuthorizationValidator;
import org.apache.accumulo.access.InvalidAccessExpressionException;
/**
@@ -47,47 +47,51 @@ public final class Tokenizer {
"_-:./".chars().forEach(c -> validAuthChars[c] = true);
}
- public static boolean isValidAuthChar(byte b) {
- return validAuthChars[0xff & b];
+ public static boolean isValidAuthChar(char b) {
+ return validAuthChars[0xff & b] && b < 256;
}
- private byte[] expression;
+ private char[] expression;
+ private int len;
private int index;
private final AuthorizationToken authorizationToken = new AuthorizationToken();
public static class AuthorizationToken {
- public byte[] data;
+ public char[] data;
public int start;
public int len;
+ public boolean hasEscapes;
+ public AuthorizationValidator.AuthorizationCharacters quoting;
+
}
- Tokenizer(byte[] expression) {
- this.expression = expression;
- authorizationToken.data = expression;
+ Tokenizer(char[] expression) {
+ reset(expression, expression.length);
}
- void reset(byte[] expression) {
+ void reset(char[] expression, int len) {
this.expression = expression;
- authorizationToken.data = expression;
this.index = 0;
+ this.len = len;
+ this.authorizationToken.data = expression;
}
boolean hasNext() {
- return index < expression.length;
+ return index < len;
}
public void advance() {
index++;
}
- public void next(byte expected) {
+ public void next(char expected) {
if (!hasNext()) {
- error("Expected '" + (char) expected + "' instead saw end of input");
+ error("Expected '" + expected + "' instead saw end of input");
}
if (expression[index] != expected) {
- error("Expected '" + (char) expected + "' instead saw '" + (char) (expression[index]) + "'");
+ error("Expected '" + expected + "' instead saw '" + (expression[index]) + "'");
}
index++;
}
@@ -97,17 +101,13 @@ public final class Tokenizer {
}
public void error(String msg, int idx) {
- throw new InvalidAccessExpressionException(msg, new String(expression, UTF_8), idx);
+ throw new InvalidAccessExpressionException(msg, new String(expression, 0, len), idx);
}
- byte peek() {
+ char peek() {
return expression[index];
}
- byte[] expression() {
- return expression;
- }
-
public int curentOffset() {
return index;
}
@@ -116,17 +116,19 @@ public final class Tokenizer {
if (isQuoteSymbol(expression[index])) {
int start = ++index;
- while (index < expression.length && !isQuoteSymbol(expression[index])) {
+ boolean hasEscapes = false;
+ while (index < len && !isQuoteSymbol(expression[index])) {
if (isBackslashSymbol(expression[index])) {
index++;
- if (index == expression.length || !isQuoteOrSlash(expression[index])) {
+ if (index == len || !isQuoteOrSlash(expression[index])) {
error("Invalid escaping within quotes", index - 1);
}
+ hasEscapes = true;
}
index++;
}
- if (index == expression.length) {
+ if (index == len) {
error("Unclosed quote", start - 1);
}
@@ -136,6 +138,8 @@ public final class Tokenizer {
authorizationToken.start = start;
authorizationToken.len = index - start;
+ authorizationToken.hasEscapes = hasEscapes;
+ authorizationToken.quoting = AuthorizationValidator.AuthorizationCharacters.ANY;
if (includeQuotes) {
authorizationToken.start--;
@@ -148,15 +152,16 @@ public final class Tokenizer {
} else if (isValidAuthChar(expression[index])) {
int start = index;
- while (index < expression.length && isValidAuthChar(expression[index])) {
+ do {
index++;
- }
+ } while (index < len && isValidAuthChar(expression[index]));
authorizationToken.start = start;
authorizationToken.len = index - start;
+ authorizationToken.hasEscapes = false;
+ authorizationToken.quoting = AuthorizationValidator.AuthorizationCharacters.BASIC;
return authorizationToken;
} else {
- error(
- "Expected a '(' character or an authorization token instead saw '" + (char) peek() + "'");
+ error("Expected a '(' character or an authorization token instead saw '" + peek() + "'");
return null;
}
}
diff --git a/core/src/main/resources/org/apache/accumulo/access/specification/AccessExpression.abnf b/core/src/main/resources/org/apache/accumulo/access/specification/AccessExpression.abnf
index 30f45b3..f2aae57 100644
--- a/core/src/main/resources/org/apache/accumulo/access/specification/AccessExpression.abnf
+++ b/core/src/main/resources/org/apache/accumulo/access/specification/AccessExpression.abnf
@@ -28,9 +28,8 @@ and-expression = "&" (access-token / paren-expression) [and-expression
or-expression = "|" (access-token / paren-expression) [or-expression]
access-token = 1*( ALPHA / DIGIT / "_" / "-" / "." / ":" / slash )
-access-token =/ DQUOTE 1*(utf8-subset / escaped) DQUOTE
+access-token =/ DQUOTE 1*(unicode-subset / escaped) DQUOTE
-utf8-subset = %x20-21 / %x23-5B / %x5D-7E / unicode-beyond-ascii ; utf8 minus '"' and '\'
-unicode-beyond-ascii = %x0080-D7FF / %xE000-10FFFF
+unicode-subset = %x00-21 / %x23-5B / %x5D-7F / unicode-beyond-ascii ; unicode minus '"' and '\'
escaped = "\" DQUOTE / "\\"
slash = "/"
diff --git a/core/src/test/java/org/apache/accumulo/access/tests/AccessEvaluatorTest.java b/core/src/test/java/org/apache/accumulo/access/tests/AccessEvaluatorTest.java
index 35a0d5c..b72b2a0 100644
--- a/core/src/test/java/org/apache/accumulo/access/tests/AccessEvaluatorTest.java
+++ b/core/src/test/java/org/apache/accumulo/access/tests/AccessEvaluatorTest.java
@@ -19,8 +19,6 @@
package org.apache.accumulo.access.tests;
import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.apache.accumulo.access.AccessExpression.quote;
-import static org.apache.accumulo.access.AccessExpression.unquote;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -29,17 +27,17 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.IOException;
import java.lang.reflect.Type;
import java.util.ArrayList;
+import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
+import org.apache.accumulo.access.Access;
import org.apache.accumulo.access.AccessEvaluator;
-import org.apache.accumulo.access.AccessExpression;
-import org.apache.accumulo.access.Authorizations;
+import org.apache.accumulo.access.AuthorizationValidator;
import org.apache.accumulo.access.InvalidAccessExpressionException;
import org.apache.accumulo.access.impl.AccessEvaluatorImpl;
-import org.apache.accumulo.access.impl.BytesWrapper;
import org.junit.jupiter.api.Test;
import com.google.gson.Gson;
@@ -85,28 +83,30 @@ public class AccessEvaluatorTest {
assertFalse(testData.isEmpty());
+ var access = Access.builder().build();
+
for (var testSet : testData) {
System.out.println("runTestCases for " + testSet.description);
AccessEvaluator evaluator;
assertTrue(testSet.auths.length >= 1);
if (testSet.auths.length == 1) {
- evaluator = AccessEvaluator.of(Authorizations.of(Set.of(testSet.auths[0])));
- runTestCases(testSet, evaluator);
+ evaluator = access.newEvaluator(access.newAuthorizations(Set.of(testSet.auths[0])));
+ runTestCases(access, testSet, evaluator);
Set<String> auths = Stream.of(testSet.auths[0]).collect(Collectors.toSet());
- evaluator = AccessEvaluator.of(auths::contains);
- runTestCases(testSet, evaluator);
+ evaluator = access.newEvaluator(auths::contains);
+ runTestCases(access, testSet, evaluator);
} else {
- var authSets = Stream.of(testSet.auths).map(a -> Authorizations.of(Set.of(a)))
+ var authSets = Stream.of(testSet.auths).map(a -> access.newAuthorizations(Set.of(a)))
.collect(Collectors.toList());
- evaluator = AccessEvaluator.of(authSets);
- runTestCases(testSet, evaluator);
+ evaluator = access.newEvaluator(authSets);
+ runTestCases(access, testSet, evaluator);
}
}
-
}
- private static void runTestCases(TestDataSet testSet, AccessEvaluator evaluator) {
+ private static void runTestCases(Access accumuloAccess, TestDataSet testSet,
+ AccessEvaluator evaluator) {
assertFalse(testSet.tests.isEmpty());
@@ -120,52 +120,42 @@ public class AccessEvaluatorTest {
// exception
if (tests.expectedResult == ExpectedResult.ACCESSIBLE
|| tests.expectedResult == ExpectedResult.INACCESSIBLE) {
- AccessExpression.validate(expression);
- AccessExpression.validate(expression.getBytes(UTF_8));
- assertEquals(expression, AccessExpression.of(expression).getExpression());
- assertEquals(expression, AccessExpression.of(expression.getBytes(UTF_8)).getExpression());
- // parsing an expression will strip uneeded outer parens
- assertTrue(expression.contains(AccessExpression.parse(expression).getExpression()));
- assertTrue(expression
- .contains(AccessExpression.parse(expression.getBytes(UTF_8)).getExpression()));
- AccessExpression.findAuthorizations(expression, auth -> {});
- AccessExpression.findAuthorizations(expression.getBytes(UTF_8), auth -> {});
+ accumuloAccess.validateExpression(expression);
+ assertEquals(expression, accumuloAccess.newExpression(expression).getExpression());
+ // parsing an expression will strip unneeded outer parens
+ assertTrue(
+ expression.contains(accumuloAccess.newParsedExpression(expression).getExpression()));
+ accumuloAccess.findAuthorizations(expression, auth -> {});
}
switch (tests.expectedResult) {
case ACCESSIBLE:
assertTrue(evaluator.canAccess(expression), expression);
- assertTrue(evaluator.canAccess(expression.getBytes(UTF_8)), expression);
- assertTrue(evaluator.canAccess(AccessExpression.of(expression)), expression);
- assertTrue(evaluator.canAccess(AccessExpression.parse(expression)), expression);
- assertTrue(evaluator.canAccess(AccessExpression.parse(expression).getExpression()),
+ assertTrue(evaluator.canAccess(accumuloAccess.newExpression(expression)), expression);
+ assertTrue(evaluator.canAccess(accumuloAccess.newParsedExpression(expression)),
+ expression);
+ assertTrue(
+ evaluator.canAccess(accumuloAccess.newParsedExpression(expression).getExpression()),
expression);
break;
case INACCESSIBLE:
assertFalse(evaluator.canAccess(expression), expression);
- assertFalse(evaluator.canAccess(expression.getBytes(UTF_8)), expression);
- assertFalse(evaluator.canAccess(AccessExpression.of(expression)), expression);
- assertFalse(evaluator.canAccess(AccessExpression.parse(expression)), expression);
- assertFalse(evaluator.canAccess(AccessExpression.parse(expression).getExpression()),
+ assertFalse(evaluator.canAccess(accumuloAccess.newExpression(expression)), expression);
+ assertFalse(evaluator.canAccess(accumuloAccess.newParsedExpression(expression)),
+ expression);
+ assertFalse(
+ evaluator.canAccess(accumuloAccess.newParsedExpression(expression).getExpression()),
expression);
break;
case ERROR:
assertThrows(InvalidAccessExpressionException.class,
() -> evaluator.canAccess(expression), expression);
assertThrows(InvalidAccessExpressionException.class,
- () -> evaluator.canAccess(expression.getBytes(UTF_8)), expression);
- assertThrows(InvalidAccessExpressionException.class,
- () -> AccessExpression.validate(expression), expression);
- assertThrows(InvalidAccessExpressionException.class,
- () -> AccessExpression.validate(expression.getBytes(UTF_8)), expression);
- assertThrows(InvalidAccessExpressionException.class,
- () -> AccessExpression.of(expression), expression);
- assertThrows(InvalidAccessExpressionException.class,
- () -> AccessExpression.of(expression.getBytes(UTF_8)), expression);
+ () -> accumuloAccess.validateExpression(expression), expression);
assertThrows(InvalidAccessExpressionException.class,
- () -> AccessExpression.parse(expression), expression);
+ () -> accumuloAccess.newExpression(expression), expression);
assertThrows(InvalidAccessExpressionException.class,
- () -> AccessExpression.parse(expression.getBytes(UTF_8)), expression);
+ () -> accumuloAccess.newParsedExpression(expression), expression);
break;
default:
throw new IllegalArgumentException();
@@ -176,48 +166,49 @@ public class AccessEvaluatorTest {
@Test
public void testEmptyAuthorizations() {
- assertThrows(IllegalArgumentException.class,
- () -> AccessEvaluator.of(Authorizations.of(Set.of(""))));
- assertThrows(IllegalArgumentException.class,
- () -> AccessEvaluator.of(Authorizations.of(Set.of("", "A"))));
- assertThrows(IllegalArgumentException.class,
- () -> AccessEvaluator.of(Authorizations.of(Set.of("A", ""))));
- assertThrows(IllegalArgumentException.class,
- () -> AccessEvaluator.of(Authorizations.of(Set.of(""))));
+ var access = Access.builder().build();
+ assertThrows(IllegalArgumentException.class, () -> access.newAuthorizations(Set.of("")));
+ assertThrows(IllegalArgumentException.class, () -> access.newAuthorizations(Set.of("", "A")));
+ assertThrows(IllegalArgumentException.class, () -> access.newAuthorizations(Set.of("A", "")));
+ assertThrows(IllegalArgumentException.class, () -> access.newAuthorizations(Set.of("")));
}
@Test
public void testSpecialChars() {
+ var access = Access.builder().build();
// special chars do not need quoting
for (String qt : List.of("A_", "_", "A_C", "_C")) {
- assertEquals(qt, quote(qt));
+ assertEquals(qt, access.quote(qt));
for (char c : new char[] {'/', ':', '-', '.'}) {
String qt2 = qt.replace('_', c);
- assertEquals(qt2, quote(qt2));
+ assertEquals(qt2, access.quote(qt2));
}
}
- assertEquals("a_b:c/d.e", quote("a_b:c/d.e"));
+ assertEquals("a_b:c/d.e", access.quote("a_b:c/d.e"));
}
@Test
public void testQuote() {
- assertEquals("\"A#C\"", quote("A#C"));
- assertEquals("A#C", unquote(quote("A#C")));
- assertEquals("\"A\\\"C\"", quote("A\"C"));
- assertEquals("A\"C", unquote(quote("A\"C")));
- assertEquals("\"A\\\"\\\\C\"", quote("A\"\\C"));
- assertEquals("A\"\\C", unquote(quote("A\"\\C")));
- assertEquals("ACS", quote("ACS"));
- assertEquals("ACS", unquote(quote("ACS")));
- assertEquals("\"δΉ\"", quote("δΉ"));
- assertEquals("δΉ", unquote(quote("δΉ")));
- assertEquals("\"δΊε\"", quote("δΊε"));
- assertEquals("δΊε", unquote(quote("δΊε")));
+ var access = Access.builder().build();
+ assertEquals("\"A#C\"", access.quote("A#C"));
+ assertEquals("A#C", access.unquote(access.quote("A#C")));
+ assertEquals("\"A\\\"C\"", access.quote("A\"C"));
+ assertEquals("A\"C", access.unquote(access.quote("A\"C")));
+ assertEquals("\"A\\\"\\\\C\"", access.quote("A\"\\C"));
+ assertEquals("A\"\\C", access.unquote(access.quote("A\"\\C")));
+ assertEquals("ACS", access.quote("ACS"));
+ assertEquals("ACS", access.unquote(access.quote("ACS")));
+ assertEquals("\"δΉ\"", access.quote("δΉ"));
+ assertEquals("δΉ", access.unquote(access.quote("δΉ")));
+ assertEquals("\"δΊε\"", access.quote("δΊε"));
+ assertEquals("δΊε", access.unquote(access.quote("δΊε")));
+ assertThrows(IllegalArgumentException.class, () -> access.quote(""));
+ assertThrows(IllegalArgumentException.class, () -> access.unquote(""));
}
private static String unescape(String s) {
- return AccessEvaluatorImpl.unescape(new BytesWrapper(s.getBytes(UTF_8)));
+ return AccessEvaluatorImpl.unescape(s).toString();
}
@Test
@@ -235,5 +226,46 @@ public class AccessEvaluatorTest {
.forEach(seq -> assertThrows(IllegalArgumentException.class, () -> unescape(seq), message));
}
+ @Test
+ public void testNullAuthValidator() {
+ assertThrows(NullPointerException.class,
+ () -> Access.builder().authorizationValidator(null).build());
+ }
+
+ @Test
+ public void testAuthValidation() {
+ // This test ensures that unquoted and unescaped auths are passed to the auth validator.
+ HashSet<String> seenAuths = new HashSet<>();
+ AuthorizationValidator authorizationValidator = (auth, authChars) -> {
+ seenAuths.add(auth.toString());
+ return AuthorizationValidator.DEFAULT.test(auth, authChars);
+ };
+ var access = Access.builder().authorizationValidator(authorizationValidator).build();
+ var qa1 = access.quote("A");
+ var qa2 = access.quote("B/C");
+ var qa3 = access.quote("D\\E");
+
+ assertEquals(Set.of("A", "B/C", "D\\E"), seenAuths);
+ seenAuths.clear();
+
+ assertEquals("A", access.unquote(qa1));
+ assertEquals("B/C", access.unquote(qa2));
+ assertEquals("D\\E", access.unquote(qa3));
+
+ assertEquals(Set.of("A", "B/C", "D\\E"), seenAuths);
+ seenAuths.clear();
+
+ var eval = access.newEvaluator(access.newAuthorizations(Set.of("A")));
+ assertFalse(eval.canAccess(qa1 + "&" + qa2 + "&" + qa3));
+ assertEquals(Set.of("A", "B/C", "D\\E"), seenAuths);
+ seenAuths.clear();
+
+ eval = access.newEvaluator(a -> a.equals("A"));
+ assertFalse(eval.canAccess(qa1 + "&" + qa2 + "&" + qa3));
+ assertEquals(Set.of("A", "B/C", "D\\E"), seenAuths);
+ seenAuths.clear();
+
+ }
+
// TODO need to copy all test from Accumulo
}
diff --git a/core/src/test/java/org/apache/accumulo/access/tests/AccessExpressionBenchmark.java b/core/src/test/java/org/apache/accumulo/access/tests/AccessExpressionBenchmark.java
index b9706b2..a5eb3b4 100644
--- a/core/src/test/java/org/apache/accumulo/access/tests/AccessExpressionBenchmark.java
+++ b/core/src/test/java/org/apache/accumulo/access/tests/AccessExpressionBenchmark.java
@@ -28,10 +28,8 @@ import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.Stream;
+import org.apache.accumulo.access.Access;
import org.apache.accumulo.access.AccessEvaluator;
-import org.apache.accumulo.access.AccessExpression;
-import org.apache.accumulo.access.Authorizations;
-import org.apache.accumulo.access.ParsedAccessExpression;
import org.apache.accumulo.core.security.ColumnVisibility;
import org.apache.accumulo.core.security.VisibilityEvaluator;
import org.apache.accumulo.core.security.VisibilityParseException;
@@ -74,12 +72,14 @@ public class AccessExpressionBenchmark {
public static class EvaluatorTests {
AccessEvaluator evaluator;
- List<byte[]> expressions;
+ List<String> expressions;
}
@State(Scope.Benchmark)
public static class BenchmarkState {
+ private Access access;
+
private ArrayList<byte[]> allTestExpressions;
private ArrayList<String> allTestExpressionsStr;
@@ -90,6 +90,7 @@ public class AccessExpressionBenchmark {
@Setup
public void loadData() throws IOException {
+ access = Access.builder().build();
List<AccessEvaluatorTest.TestDataSet> testData = AccessEvaluatorTest.readTestData();
allTestExpressions = new ArrayList<>();
allTestExpressionsStr = new ArrayList<>();
@@ -120,11 +121,12 @@ public class AccessExpressionBenchmark {
et.expressions = new ArrayList<>();
if (testDataSet.auths.length == 1) {
- et.evaluator = AccessEvaluator.of(Authorizations.of(Set.of(testDataSet.auths[0])));
+ et.evaluator =
+ access.newEvaluator(access.newAuthorizations(Set.of(testDataSet.auths[0])));
} else {
- var authSets = Stream.of(testDataSet.auths).map(a -> Authorizations.of(Set.of(a)))
+ var authSets = Stream.of(testDataSet.auths).map(a -> access.newAuthorizations(Set.of(a)))
.collect(Collectors.toList());
- et.evaluator = AccessEvaluator.of(authSets);
+ et.evaluator = access.newEvaluator(authSets);
}
for (var tests : testDataSet.tests) {
@@ -133,7 +135,7 @@ public class AccessExpressionBenchmark {
allTestExpressionsStr.add(exp);
byte[] byteExp = exp.getBytes(UTF_8);
allTestExpressions.add(byteExp);
- et.expressions.add(byteExp);
+ et.expressions.add(exp);
vet.expressions.add(byteExp);
vet.columnVisibilities.add(new ColumnVisibility(byteExp));
}
@@ -168,8 +170,9 @@ public class AccessExpressionBenchmark {
*/
@Benchmark
public void measureBytesValidation(BenchmarkState state, Blackhole blackhole) {
+ var accumuloAccess = state.access;
for (byte[] accessExpression : state.getBytesExpressions()) {
- AccessExpression.validate(accessExpression);
+ accumuloAccess.validateExpression(new String(accessExpression, UTF_8));
}
}
@@ -178,8 +181,9 @@ public class AccessExpressionBenchmark {
*/
@Benchmark
public void measureStringValidation(BenchmarkState state, Blackhole blackhole) {
+ var accumuloAccess = state.access;
for (String accessExpression : state.getStringExpressions()) {
- AccessExpression.validate(accessExpression);
+ accumuloAccess.validateExpression(accessExpression);
}
}
@@ -189,8 +193,9 @@ public class AccessExpressionBenchmark {
*/
@Benchmark
public void measureCreateParseTree(BenchmarkState state, Blackhole blackhole) {
+ var accumuloAccess = state.access;
for (String accessExpression : state.getStringExpressions()) {
- blackhole.consume(ParsedAccessExpression.parse(accessExpression));
+ blackhole.consume(accumuloAccess.newParsedExpression(accessExpression));
}
}
@@ -200,7 +205,7 @@ public class AccessExpressionBenchmark {
@Benchmark
public void measureParseAndEvaluation(BenchmarkState state, Blackhole blackhole) {
for (EvaluatorTests evaluatorTests : state.getEvaluatorTests()) {
- for (byte[] expression : evaluatorTests.expressions) {
+ for (String expression : evaluatorTests.expressions) {
blackhole.consume(evaluatorTests.evaluator.canAccess(expression));
}
}
@@ -250,10 +255,13 @@ public class AccessExpressionBenchmark {
System.out.println("Number of Expressions: " + numExpressions);
- Options opt = new OptionsBuilder().include(AccessExpressionBenchmark.class.getSimpleName())
- .mode(Mode.Throughput).operationsPerInvocation(numExpressions)
- .timeUnit(TimeUnit.MICROSECONDS).warmupTime(TimeValue.seconds(5)).warmupIterations(3)
- .measurementIterations(4).forks(3).build();
+ var include = System.getenv().getOrDefault("ACCESS_BENCHMARK",
+ AccessExpressionBenchmark.class.getSimpleName());
+
+ Options opt = new OptionsBuilder().include(include).mode(Mode.Throughput)
+ .operationsPerInvocation(numExpressions).timeUnit(TimeUnit.MICROSECONDS)
+ .warmupTime(TimeValue.seconds(5)).warmupIterations(3).measurementIterations(4).forks(3)
+ .build();
new Runner(opt).run();
}
}
diff --git a/core/src/test/java/org/apache/accumulo/access/tests/AccessExpressionTest.java b/core/src/test/java/org/apache/accumulo/access/tests/AccessExpressionTest.java
index c7f4c40..55abca3 100644
--- a/core/src/test/java/org/apache/accumulo/access/tests/AccessExpressionTest.java
+++ b/core/src/test/java/org/apache/accumulo/access/tests/AccessExpressionTest.java
@@ -31,13 +31,14 @@ import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URISyntaxException;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
+import org.apache.accumulo.access.Access;
import org.apache.accumulo.access.AccessExpression;
+import org.apache.accumulo.access.AuthorizationValidator;
import org.apache.accumulo.access.InvalidAccessExpressionException;
import org.apache.accumulo.access.ParsedAccessExpression;
import org.junit.jupiter.api.Test;
@@ -47,6 +48,12 @@ public class AccessExpressionTest {
@Test
public void testGetAuthorizations() {
+ HashSet<String> seenAuths = new HashSet<>();
+ AuthorizationValidator authorizationValidator = (auth, authChars) -> {
+ seenAuths.add(auth.toString());
+ return AuthorizationValidator.DEFAULT.test(auth, authChars);
+ };
+ var access = Access.builder().authorizationValidator(authorizationValidator).build();
// Test data pairs where the first entry of each pair is an expression to normalize and second
// is the expected authorization in the expression
var testData = new ArrayList<List<String>>();
@@ -66,24 +73,22 @@ public class AccessExpressionTest {
var expression = testCase.get(0);
var expected = testCase.get(1);
HashSet<String> found = new HashSet<>();
- AccessExpression.findAuthorizations(expression, found::add);
+ access.findAuthorizations(expression, found::add);
var actual = found.stream().sorted().collect(Collectors.joining(","));
assertEquals(expected, actual);
found.clear();
- AccessExpression.findAuthorizations(expression.getBytes(UTF_8), found::add);
- actual = found.stream().sorted().collect(Collectors.joining(","));
+ actual = seenAuths.stream().sorted().collect(Collectors.joining(","));
assertEquals(expected, actual);
+ seenAuths.clear();
}
}
void checkError(String expression, String expected, int index) {
- checkError(() -> AccessExpression.validate(expression), expected, index);
- checkError(() -> AccessExpression.validate(expression.getBytes(UTF_8)), expected, index);
- checkError(() -> AccessExpression.of(expression), expected, index);
- checkError(() -> AccessExpression.of(expression.getBytes(UTF_8)), expected, index);
- checkError(() -> AccessExpression.parse(expression), expected, index);
- checkError(() -> AccessExpression.parse(expression.getBytes(UTF_8)), expected, index);
+ var access = Access.builder().build();
+ checkError(() -> access.validateExpression(expression), expected, index);
+ checkError(() -> access.newExpression(expression), expected, index);
+ checkError(() -> access.newParsedExpression(expression), expected, index);
}
void checkError(Executable executable, String expected, int index) {
@@ -129,10 +134,11 @@ public class AccessExpressionTest {
@Test
public void testEqualsHashcode() {
- var ae1 = AccessExpression.of("A&B");
- var ae2 = AccessExpression.of("A&C");
- var ae3 = AccessExpression.of("A&B");
- var ae4 = AccessExpression.parse("A&B");
+ var access = Access.builder().build();
+ var ae1 = access.newExpression("A&B");
+ var ae2 = access.newExpression("A&C");
+ var ae3 = access.newExpression("A&B");
+ var ae4 = access.newParsedExpression("A&B");
assertEquals(ae1, ae3);
assertEquals(ae1, ae4);
@@ -183,26 +189,23 @@ public class AccessExpressionTest {
@Test
public void testEmpty() {
+ var access = Access.builder().build();
// do not expect empty expression to fail validation
- AccessExpression.validate(new byte[0]);
- AccessExpression.validate("");
- assertEquals("", AccessExpression.of(new byte[0]).getExpression());
- assertEquals("", AccessExpression.of("").getExpression());
-
- for (var parsed : List.of(AccessExpression.parse(new byte[0]), AccessExpression.parse(""))) {
- assertEquals("", parsed.getExpression());
- assertTrue(parsed.getChildren().isEmpty());
- assertEquals(ParsedAccessExpression.ExpressionType.EMPTY, parsed.getType());
- }
+ access.validateExpression("");
+ assertEquals("", access.newExpression("").getExpression());
+
+ var parsed = access.newParsedExpression("");
+ assertEquals("", parsed.getExpression());
+ assertTrue(parsed.getChildren().isEmpty());
+ assertEquals(ParsedAccessExpression.ExpressionType.EMPTY, parsed.getType());
}
@Test
public void testImmutable() {
- byte[] exp = "A&B&(C|D)".getBytes(UTF_8);
- var exp1 = AccessExpression.of(exp);
- var exp2 = AccessExpression.parse(exp);
- Arrays.fill(exp, (byte) 0);
- assertEquals("A&B&(C|D)", exp1.getExpression());
+ var access = Access.builder().build();
+ var exp = "A&B&(C|D)";
+ var exp2 = access.newParsedExpression(exp);
+
assertEquals("A&B&(C|D)", exp2.getExpression());
assertEquals("A", exp2.getChildren().get(0).getExpression());
@@ -219,22 +222,13 @@ public class AccessExpressionTest {
@Test
public void testNull() {
- assertThrows(NullPointerException.class, () -> AccessExpression.parse((byte[]) null));
- assertThrows(NullPointerException.class, () -> AccessExpression.parse((String) null));
- assertThrows(NullPointerException.class, () -> AccessExpression.validate((byte[]) null));
- assertThrows(NullPointerException.class, () -> AccessExpression.validate((String) null));
- assertThrows(NullPointerException.class, () -> AccessExpression.of((byte[]) null));
- assertThrows(NullPointerException.class, () -> AccessExpression.of((String) null));
- assertThrows(NullPointerException.class,
- () -> AccessExpression.findAuthorizations((byte[]) null, auth -> {}));
- assertThrows(NullPointerException.class,
- () -> AccessExpression.findAuthorizations((String) null, auth -> {}));
- assertThrows(NullPointerException.class,
- () -> AccessExpression.findAuthorizations("A&B".getBytes(UTF_8), null));
- assertThrows(NullPointerException.class,
- () -> AccessExpression.findAuthorizations("A&B", null));
- assertThrows(NullPointerException.class, () -> AccessExpression.quote((byte[]) null));
- assertThrows(NullPointerException.class, () -> AccessExpression.quote((String) null));
- assertThrows(NullPointerException.class, () -> AccessExpression.unquote(null));
+ var access = Access.builder().build();
+ assertThrows(NullPointerException.class, () -> access.newParsedExpression(null));
+ assertThrows(NullPointerException.class, () -> access.validateExpression(null));
+ assertThrows(NullPointerException.class, () -> access.newExpression(null));
+ assertThrows(NullPointerException.class, () -> access.findAuthorizations(null, auth -> {}));
+ assertThrows(NullPointerException.class, () -> access.findAuthorizations("A&B", null));
+ assertThrows(NullPointerException.class, () -> access.quote(null));
+ assertThrows(NullPointerException.class, () -> access.unquote(null));
}
}
diff --git a/core/src/test/java/org/apache/accumulo/access/tests/AuthorizationTest.java b/core/src/test/java/org/apache/accumulo/access/tests/AuthorizationTest.java
index 53d8164..b869465 100644
--- a/core/src/test/java/org/apache/accumulo/access/tests/AuthorizationTest.java
+++ b/core/src/test/java/org/apache/accumulo/access/tests/AuthorizationTest.java
@@ -18,26 +18,36 @@
*/
package org.apache.accumulo.access.tests;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import java.util.List;
import java.util.Set;
+import org.apache.accumulo.access.Access;
import org.apache.accumulo.access.Authorizations;
+import org.apache.accumulo.access.InvalidAccessExpressionException;
+import org.apache.accumulo.access.InvalidAuthorizationException;
+import org.apache.accumulo.access.impl.Tokenizer;
import org.junit.jupiter.api.Test;
public class AuthorizationTest {
@Test
public void testEquality() {
- Authorizations auths1 = Authorizations.of(Set.of("A", "B", "C"));
- Authorizations auths2 = Authorizations.of(Set.of("A", "B", "C"));
+ var access = Access.builder().build();
+ Authorizations auths1 = access.newAuthorizations(Set.of("A", "B", "C"));
+ Authorizations auths2 = access.newAuthorizations(Set.of("A", "B", "C"));
assertEquals(auths1, auths2);
assertEquals(auths1.hashCode(), auths2.hashCode());
- Authorizations auths3 = Authorizations.of(Set.of("D", "E", "F"));
+ Authorizations auths3 = access.newAuthorizations(Set.of("D", "E", "F"));
assertNotEquals(auths1, auths3);
assertNotEquals(auths1.hashCode(), auths3.hashCode());
@@ -45,11 +55,241 @@ public class AuthorizationTest {
@Test
public void testEmpty() {
+ var access = Access.builder().build();
// check if new object is allocated
- assertSame(Authorizations.of(), Authorizations.of());
- // check if optimization is working
- assertSame(Authorizations.of(), Authorizations.of(Set.of()));
- assertEquals(Set.of(), Authorizations.of().asSet());
- assertSame(Set.of(), Authorizations.of().asSet());
+ assertSame(access.newAuthorizations(Set.of()), access.newAuthorizations(Set.of()));
+ assertEquals(Set.of(), access.newAuthorizations(Set.of()).asSet());
+ assertSame(Set.of(), access.newAuthorizations(Set.of()).asSet());
+ }
+
+ @Test
+ public void testAuthorizationValidation() {
+
+ // create an instance of accumulo access that expects all auths to start with a lower case
+ // letter followed by one or more lower case letters or digits.
+ var accumuloAccess = Access.builder().authorizationValidator((auth, quoting) -> {
+ if (auth.length() < 2) {
+ return false;
+ }
+
+ char c = auth.charAt(0);
+ if (!Character.isLowerCase(c) || !Character.isLetter(c)) {
+ return false;
+ }
+
+ for (int i = 1; i < auth.length(); i++) {
+ c = auth.charAt(i);
+ boolean valid = Character.isDigit(c) || (Character.isLetter(c) && Character.isLowerCase(c));
+ if (!valid) {
+ return false;
+ }
+ }
+
+ return true;
+ }).build();
+
+ runTest("ac", "a9", "dc", "9a", accumuloAccess);
+ }
+
+ @Test
+ public void testNonUnicode() {
+ // test with a character that is not unicode
+ char c = '\u0378';
+ assertFalse(Character.isDefined(c));
+ assertFalse(Character.isISOControl(c));
+ var badAuth = new String(new char[] {'a', c});
+
+ var access = Access.builder().build();
+ runTest("ac", "a9", "dc", badAuth, access);
+ }
+
+ @Test
+ public void testControlCharacters() {
+ char c = '\u000c';
+ assertTrue(Character.isDefined(c));
+ assertTrue(Character.isISOControl(c));
+
+ var access = Access.builder().build();
+ var badAuth = new String(new char[] {'a', c});
+ runTest("ac", "a9", "dc", badAuth, access);
+ }
+
+ @Test
+ public void testReplacementCharacter() {
+ char c = '\uFFFD';
+ assertEquals(c + "", UTF_8.newDecoder().replacement());
+
+ var access = Access.builder().build();
+ var badAuth = new String(new char[] {'a', c});
+ runTest("ac", "a9", "dc", badAuth, access);
+ }
+
+ @Test
+ public void testAuthorizationCharacters() {
+ for (char c = 0; c < Character.MAX_VALUE; c++) {
+ boolean valid = (c >= 'a' && c <= 'z') | (c >= 'A' && c <= 'Z') | (c >= '0' && c <= '9')
+ | c == '_' | c == '-' | c == ':' | c == '.' | c == '/';
+ // This code had a bug where it was only considering the lower 8 bits of the 16 bits in the
+ // char and that caused an obscure and easy to miss problem. So this test was written to cover
+ // all 64k chars.
+ assertEquals(valid, Tokenizer.isValidAuthChar(c));
+ }
+ }
+
+ @Test
+ public void testUnescaped() {
+ // This test ensures that auth passed to the authorization validator are unescaped, even if they
+ // are escaped in the expression
+ var accumuloAccess = Access.builder().authorizationValidator((auth, quoting) -> {
+ for (int i = 0; i < auth.length(); i++) {
+ assertNotEquals('\\', auth.charAt(i));
+ }
+ return true;
+ }).build();
+
+ var quoted = accumuloAccess.quote("ABC\"D");
+ assertEquals('"' + "ABC\\\"D" + '"', quoted);
+ assertEquals("ABC\"D", accumuloAccess.unquote(quoted));
+
+ var auths1 = accumuloAccess.newAuthorizations(Set.of("ABC\"D", "DEF"));
+ var auths2 = accumuloAccess.newAuthorizations(Set.of("ABC\"D", "XYZ"));
+ var evaluator = accumuloAccess.newEvaluator(auths1);
+
+ assertTrue(evaluator.canAccess(quoted + "|XYZ"));
+ assertTrue(evaluator.canAccess("(XYZ&RST)|" + quoted));
+
+ assertTrue(evaluator.canAccess(accumuloAccess.newExpression("(XYZ&RST)|" + quoted)));
+ assertTrue(evaluator.canAccess(accumuloAccess.newParsedExpression("(XYZ&RST)|" + quoted)));
+ assertTrue(evaluator.canAccess(accumuloAccess.newExpression("(XYZ&RST)|" + quoted).parse()));
+
+ var multiEvaluator = accumuloAccess.newEvaluator(List.of(auths1, auths2));
+ assertTrue(multiEvaluator.canAccess(quoted + "|XYZ"));
+ assertFalse(multiEvaluator.canAccess(quoted + "&DEF"));
+ assertTrue(evaluator.canAccess(quoted + "&DEF"));
+
+ }
+
+ @Test
+ public void testMultiCharCodepoint() {
+ // Some unicode code points span two UTF-16 chars, this test ensures its possible to handle
+ // those.
+
+ String doubleChar = "";
+ // find any valid code point that takes two chars
+ for (int i = 1 << 16; i < Integer.MAX_VALUE; i++) {
+ if (Character.isDefined(i)) {
+ var dc = Character.toChars(i);
+ if (dc.length == 2) {
+ doubleChar = new String(dc);
+ break;
+ }
+ }
+ }
+
+ assertEquals(2, doubleChar.length());
+
+ // create an auth that uses doubleChar
+ var auth1 = "a" + doubleChar;
+ var auth2 = "abc";
+
+ var access = Access.builder().build();
+
+ var exp1 = access.quote(auth1) + "&" + auth2;
+ var exp2 = access.quote(auth1) + "|" + auth2;
+
+ assertEquals('"' + auth1 + '"' + "&" + auth2, exp1);
+ assertEquals('"' + auth1 + '"' + "|" + auth2, exp2);
+
+ var auths1 = access.newAuthorizations(Set.of(auth1, auth2));
+ var evaluator1 = access.newEvaluator(auths1);
+ assertTrue(evaluator1.canAccess(exp1));
+ assertTrue(evaluator1.canAccess(exp2));
+
+ var auths2 = access.newAuthorizations(Set.of(auth1));
+ var evaluator2 = access.newEvaluator(auths2);
+ assertFalse(evaluator2.canAccess(exp1));
+ assertTrue(evaluator2.canAccess(exp2));
+
+ var auths3 = access.newAuthorizations(Set.of(auth2));
+ var evaluator3 = access.newEvaluator(auths3);
+ assertFalse(evaluator3.canAccess(exp1));
+ assertTrue(evaluator3.canAccess(exp2));
+ }
+
+ private static void runTest(String goodAuth1, String goodAuth2, String goodAuth3, String badAuth,
+ Access accumuloAccess) {
+ List<String> auths = List.of(goodAuth1, goodAuth2, badAuth, goodAuth3);
+
+ var auths1 = accumuloAccess.newAuthorizations(Set.of(goodAuth1, goodAuth2));
+ var auths2 = accumuloAccess.newAuthorizations(Set.of(goodAuth3, goodAuth2));
+
+ var evaluator = accumuloAccess.newEvaluator(auths1);
+ var multiEvaluator = accumuloAccess.newEvaluator(List.of(auths1, auths2));
+ var evaluator2 = accumuloAccess.newEvaluator(auth -> auth.equals(goodAuth3));
+
+ for (int i = 0; i < 4; i++) {
+ var a1 = auths.get(i);
+ var a2 = auths.get((i + 1) % 4);
+ var a3 = auths.get((i + 2) % 4);
+ var a4 = auths.get((i + 3) % 4);
+
+ // create the same expression with the invalid auth in different places
+ var exp =
+ '"' + a1 + '"' + "|(" + '"' + a2 + '"' + "&" + '"' + a3 + '"' + ")|" + '"' + a4 + '"';
+ var exception = assertThrows(InvalidAuthorizationException.class,
+ () -> accumuloAccess.validateExpression(exp));
+ assertTrue(exception.getMessage().contains(badAuth));
+
+ exception = assertThrows(InvalidAuthorizationException.class,
+ () -> accumuloAccess.newExpression(exp));
+ assertTrue(exception.getMessage().contains(badAuth));
+
+ exception = assertThrows(InvalidAuthorizationException.class,
+ () -> accumuloAccess.newParsedExpression(exp));
+ assertTrue(exception.getMessage().contains(badAuth));
+
+ exception = assertThrows(InvalidAuthorizationException.class, () -> evaluator.canAccess(exp));
+ assertTrue(exception.getMessage().contains(badAuth));
+
+ exception =
+ assertThrows(InvalidAuthorizationException.class, () -> multiEvaluator.canAccess(exp));
+ assertTrue(exception.getMessage().contains(badAuth));
+
+ exception =
+ assertThrows(InvalidAuthorizationException.class, () -> evaluator2.canAccess(exp));
+ assertTrue(exception.getMessage().contains(badAuth));
+
+ exception = assertThrows(InvalidAuthorizationException.class,
+ () -> accumuloAccess.findAuthorizations(exp, a -> {}));
+ assertTrue(exception.getMessage().contains(badAuth));
+
+ exception = assertThrows(InvalidAuthorizationException.class,
+ () -> accumuloAccess.newAuthorizations(Set.of(a1, a2, a3, a4)));
+ assertTrue(exception.getMessage().contains(badAuth));
+
+ if (badAuth.chars().anyMatch(c -> !Tokenizer.isValidAuthChar((char) c))) {
+ // If the expression is created w/o quoting then the bad auth should just be seen as an
+ // invalid character in the expression and it should not even consult the authorization
+ // validation code. This should result in a different exception.
+ var exp2 = a1 + "|(" + a2 + "&" + a3 + ")|" + a4;
+ var exception2 =
+ assertThrows(InvalidAccessExpressionException.class, () -> evaluator.canAccess(exp2));
+ assertTrue(exception2.getMessage().contains(badAuth));
+ } else {
+ // The bad auth does not need quoting, but should still see an invalid auth exception
+ var exp2 = a1 + "|(" + a2 + "&" + a3 + ")|" + a4;
+ var exception2 =
+ assertThrows(InvalidAuthorizationException.class, () -> evaluator.canAccess(exp2));
+ assertTrue(exception2.getMessage().contains(badAuth));
+ }
+ }
+
+ var exception =
+ assertThrows(InvalidAuthorizationException.class, () -> accumuloAccess.quote(badAuth));
+ assertTrue(exception.getMessage().contains(badAuth));
+
+ exception = assertThrows(InvalidAuthorizationException.class,
+ () -> accumuloAccess.unquote('"' + badAuth + '"'));
+ assertTrue(exception.getMessage().contains(badAuth));
}
}
diff --git a/core/src/test/java/org/apache/accumulo/access/tests/ParsedAccessExpressionTest.java b/core/src/test/java/org/apache/accumulo/access/tests/ParsedAccessExpressionTest.java
index 3ef9c55..0acbdce 100644
--- a/core/src/test/java/org/apache/accumulo/access/tests/ParsedAccessExpressionTest.java
+++ b/core/src/test/java/org/apache/accumulo/access/tests/ParsedAccessExpressionTest.java
@@ -18,7 +18,6 @@
*/
package org.apache.accumulo.access.tests;
-import static java.nio.charset.StandardCharsets.UTF_8;
import static org.apache.accumulo.access.ParsedAccessExpression.ExpressionType.AND;
import static org.apache.accumulo.access.ParsedAccessExpression.ExpressionType.AUTHORIZATION;
import static org.apache.accumulo.access.ParsedAccessExpression.ExpressionType.EMPTY;
@@ -28,26 +27,44 @@ import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import java.util.HashSet;
import java.util.List;
+import java.util.Set;
-import org.apache.accumulo.access.AccessExpression;
+import org.apache.accumulo.access.Access;
+import org.apache.accumulo.access.AuthorizationValidator;
import org.apache.accumulo.access.ParsedAccessExpression;
import org.junit.jupiter.api.Test;
public class ParsedAccessExpressionTest {
@Test
public void testParsing() {
- String expression = "(BLUE&(RED|PINK|YELLOW))|((YELLOW|\"GREEN/GREY\")&(RED|BLUE))|BLACK";
- for (var parsed : List.of(AccessExpression.parse(expression),
- AccessExpression.parse(expression.getBytes(UTF_8)), AccessExpression.of(expression).parse(),
- AccessExpression.of(expression.getBytes(UTF_8)).parse())) {
+ HashSet<String> seenAuths = new HashSet<>();
+ AuthorizationValidator authorizationValidator = (auth, authChars) -> {
+ seenAuths.add(auth.toString());
+ return AuthorizationValidator.DEFAULT.test(auth, authChars);
+ };
+ var access = Access.builder().authorizationValidator(authorizationValidator).build();
+ String expression =
+ "(BLUE&(RED|PINK|YELLOW))|((YELLOW|\"GREEN/GREY\")&(RED|BLUE))|\"BLACK\\\\RED\"";
+
+ var pae1 = access.newParsedExpression(expression);
+ // check that unescaped and unquoted auths are passed in to the auth validator
+ assertEquals(Set.of("BLUE", "RED", "PINK", "YELLOW", "GREEN/GREY", "BLACK\\RED"), seenAuths);
+ seenAuths.clear();
+ var pae2 = access.newExpression(expression).parse();
+ // check that unescaped and unquoted auths are passed in to the auth validator
+ assertEquals(Set.of("BLUE", "RED", "PINK", "YELLOW", "GREEN/GREY", "BLACK\\RED"), seenAuths);
+
+ for (var parsed : List.of(pae1, pae2)) {
// verify root node
- verify("(BLUE&(RED|PINK|YELLOW))|((YELLOW|\"GREEN/GREY\")&(RED|BLUE))|BLACK", OR, 3, parsed);
+ verify("(BLUE&(RED|PINK|YELLOW))|((YELLOW|\"GREEN/GREY\")&(RED|BLUE))|\"BLACK\\\\RED\"", OR,
+ 3, parsed);
// verify all nodes at level 1 in the tree
verify("BLUE&(RED|PINK|YELLOW)", AND, 2, parsed, 0);
verify("(YELLOW|\"GREEN/GREY\")&(RED|BLUE)", AND, 2, parsed, 1);
- verify("BLACK", AUTHORIZATION, 0, parsed, 2);
+ verify("\"BLACK\\\\RED\"", AUTHORIZATION, 0, parsed, 2);
// verify all nodes at level 2 in the tree
verify("BLUE", AUTHORIZATION, 0, parsed, 0, 0);
@@ -68,16 +85,15 @@ public class ParsedAccessExpressionTest {
@Test
public void testEmpty() {
- var parsed = AccessExpression.parse("");
- verify("", EMPTY, 0, parsed);
- parsed = AccessExpression.parse(new byte[0]);
+ var access = Access.builder().build();
+ var parsed = access.newParsedExpression("");
verify("", EMPTY, 0, parsed);
}
@Test
public void testParseTwice() {
- for (var expression : List.of(AccessExpression.of("A&B"),
- AccessExpression.of("A&B".getBytes(UTF_8)))) {
+ var access = Access.builder().build();
+ for (var expression : List.of(access.newExpression("A&B"))) {
var parsed = expression.parse();
assertNotSame(expression, parsed);
assertEquals(expression.getExpression(), parsed.getExpression());
diff --git a/examples/src/main/java/org/apache/accumulo/access/examples/AccessExample.java b/examples/src/main/java/org/apache/accumulo/access/examples/AccessExample.java
index d60bcfb..b9fdd6d 100644
--- a/examples/src/main/java/org/apache/accumulo/access/examples/AccessExample.java
+++ b/examples/src/main/java/org/apache/accumulo/access/examples/AccessExample.java
@@ -25,8 +25,9 @@ import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
+import org.apache.accumulo.access.Access;
import org.apache.accumulo.access.AccessEvaluator;
-import org.apache.accumulo.access.Authorizations;
+import org.apache.accumulo.access.AuthorizationValidator;
public class AccessExample {
@@ -52,8 +53,11 @@ public class AccessExample {
out.printf("Showing accessible records using authorizations: %s%n",
Arrays.toString(authorizations));
+ var access = Access.builder().authorizationValidator(AuthorizationValidator.DEFAULT).build();
+
// Create an access evaluator using the provided authorizations
- AccessEvaluator evaluator = AccessEvaluator.of(Authorizations.of(Set.of(authorizations)));
+ AccessEvaluator evaluator =
+ access.newEvaluator(access.newAuthorizations(Set.of(authorizations)));
// Print each record whose access expression permits viewing using the provided authorizations
getData().forEach((record, accessExpression) -> {
diff --git a/examples/src/main/java/org/apache/accumulo/access/examples/ParseExamples.java b/examples/src/main/java/org/apache/accumulo/access/examples/ParseExamples.java
index d9cf134..4aff924 100644
--- a/examples/src/main/java/org/apache/accumulo/access/examples/ParseExamples.java
+++ b/examples/src/main/java/org/apache/accumulo/access/examples/ParseExamples.java
@@ -18,15 +18,13 @@
*/
package org.apache.accumulo.access.examples;
-import static org.apache.accumulo.access.AccessExpression.quote;
-import static org.apache.accumulo.access.AccessExpression.unquote;
import static org.apache.accumulo.access.ParsedAccessExpression.ExpressionType.AND;
import static org.apache.accumulo.access.ParsedAccessExpression.ExpressionType.AUTHORIZATION;
import java.util.Map;
import java.util.TreeSet;
-import org.apache.accumulo.access.AccessExpression;
+import org.apache.accumulo.access.Access;
import org.apache.accumulo.access.ParsedAccessExpression;
import org.apache.accumulo.access.ParsedAccessExpression.ExpressionType;
@@ -36,6 +34,8 @@ import org.apache.accumulo.access.ParsedAccessExpression.ExpressionType;
*/
public class ParseExamples {
+ public static final Access ACCESS = Access.builder().build();
+
private ParseExamples() {}
/**
@@ -47,10 +47,10 @@ public class ParseExamples {
// If the term is quoted in the expression, the quotes will be preserved. Calling unquote()
// will only unescape and unquote if the string is quoted, otherwise it returns the string as
// is.
- String auth = unquote(parsed.getExpression());
+ String auth = ACCESS.unquote(parsed.getExpression());
// Must quote any authorization that needs it. Calling quote() will only quote and escape if
// needed, otherwise it returns the string as is.
- expressionBuilder.append(quote(replacements.getOrDefault(auth, auth)));
+ expressionBuilder.append(ACCESS.quote(replacements.getOrDefault(auth, auth)));
} else {
String operator = parsed.getType() == AND ? "&" : "|";
String sep = "";
@@ -103,7 +103,7 @@ public class ParseExamples {
if (cmp == 0) {
if (type == AUTHORIZATION) {
// sort based on the unquoted and unescaped form of the authorization
- cmp = unquote(expression).compareTo(unquote(o.expression));
+ cmp = ACCESS.unquote(expression).compareTo(ACCESS.unquote(o.expression));
} else {
cmp = expression.compareTo(o.expression);
}
@@ -170,8 +170,8 @@ public class ParseExamples {
if (parsed.getType() == AUTHORIZATION) {
// If the authorization is quoted and it does not need to be quoted then the following two
// lines will remove the unnecessary quoting.
- String unquoted = AccessExpression.unquote(parsed.getExpression());
- String quoted = AccessExpression.quote(unquoted);
+ String unquoted = ACCESS.unquote(parsed.getExpression());
+ String quoted = ACCESS.quote(unquoted);
return new NormalizedExpression(quoted, parsed.getType());
} else {
// The tree set does the work of sorting and deduplicating sub expressions.
@@ -217,7 +217,7 @@ public class ParseExamples {
public static void main(String[] args) {
- var parsed = AccessExpression.parse("((RED&GREEN)|(PINK&BLUE))");
+ var parsed = ACCESS.newParsedExpression("((RED&GREEN)|(PINK&BLUE))");
System.out.printf("Operating on %s%n", parsed);
diff --git a/examples/src/test/java/org/apache/accumulo/access/examples/test/ParseExamplesTest.java b/examples/src/test/java/org/apache/accumulo/access/examples/test/ParseExamplesTest.java
index 6800a01..c34d045 100644
--- a/examples/src/test/java/org/apache/accumulo/access/examples/test/ParseExamplesTest.java
+++ b/examples/src/test/java/org/apache/accumulo/access/examples/test/ParseExamplesTest.java
@@ -18,7 +18,7 @@
*/
package org.apache.accumulo.access.examples.test;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.apache.accumulo.access.examples.ParseExamples.ACCESS;
import static org.apache.accumulo.access.examples.ParseExamples.replaceAuthorizations;
import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -26,7 +26,6 @@ import java.util.ArrayList;
import java.util.List;
import java.util.Map;
-import org.apache.accumulo.access.AccessExpression;
import org.apache.accumulo.access.examples.ParseExamples;
import org.junit.jupiter.api.Test;
@@ -90,11 +89,7 @@ public class ParseExamplesTest {
var expression = testCase.get(0);
var expected = testCase.get(1);
- var actual = ParseExamples.normalize(AccessExpression.parse(expression)).expression;
- assertEquals(expected, actual);
-
- actual =
- ParseExamples.normalize(AccessExpression.parse(expression.getBytes(UTF_8))).expression;
+ var actual = ParseExamples.normalize(ACCESS.newParsedExpression(expression)).expression;
assertEquals(expected, actual);
}
}
@@ -102,13 +97,13 @@ public class ParseExamplesTest {
@Test
public void testReplace() {
// Test replacement code w/ quoting and escaping.
- var parsed = AccessExpression.parse("((RED&\"ESC\\\\\")|(PINK&BLUE))");
+ var parsed = ACCESS.newParsedExpression("((RED&\"ESC\\\\\")|(PINK&BLUE))");
StringBuilder expressionBuilder = new StringBuilder();
replaceAuthorizations(parsed, expressionBuilder, Map.of("ESC\\", "NEEDS+QUOTE"));
assertEquals("(RED&\"NEEDS+QUOTE\")|(PINK&BLUE)", expressionBuilder.toString());
// Test replacing multiple
- parsed = AccessExpression.parse("((RED&(GREEN|YELLOW))|(PINK&BLUE))");
+ parsed = ACCESS.newParsedExpression("((RED&(GREEN|YELLOW))|(PINK&BLUE))");
expressionBuilder = new StringBuilder();
replaceAuthorizations(parsed, expressionBuilder, Map.of("RED", "ROUGE", "GREEN", "AQUA"));
assertEquals("(ROUGE&(AQUA|YELLOW))|(PINK&BLUE)", expressionBuilder.toString());
diff --git a/src/build/ci/spotbugs-exclude.xml b/src/build/ci/spotbugs-exclude.xml
index c7e7650..797c675 100644
--- a/src/build/ci/spotbugs-exclude.xml
+++ b/src/build/ci/spotbugs-exclude.xml
@@ -23,4 +23,9 @@
<Match>
<Class name="~.*[.]jmh_generated[.].*" />
</Match>
+<Match>
+ <Class name="org.apache.accumulo.access.impl.CharsWrapper" />
+ <Method name="set" params="char[],int,int" returns="void" />
+ <Bug pattern="EI_EXPOSE_REP2" />
+</Match>
</FindBugsFilter>