Merge branch 'master' into SLING-11229-SLING-11230
diff --git a/src/main/java/org/apache/sling/jcr/resource/internal/helper/JcrResourceUtil.java b/src/main/java/org/apache/sling/jcr/resource/internal/helper/JcrResourceUtil.java
index 76b7718..986100d 100644
--- a/src/main/java/org/apache/sling/jcr/resource/internal/helper/JcrResourceUtil.java
+++ b/src/main/java/org/apache/sling/jcr/resource/internal/helper/JcrResourceUtil.java
@@ -43,7 +43,7 @@
/**
* Helper method to execute a JCR query.
- *
+ *
* @param session the session
* @param query the query
* @param language the language
@@ -52,8 +52,26 @@
*/
public static QueryResult query(Session session, String query,
String language) throws RepositoryException {
+ return query(session, query, language, 0, Long.MAX_VALUE);
+ }
+
+ /**
+ * Helper method to execute a JCR query.
+ *
+ * @param session the session
+ * @param query the query
+ * @param language the language
+ * @param offset the offset to start at
+ * @param limit the limit to the number of results to return
+ * @return the query's result
+ * @throws RepositoryException if the {@link QueryManager} cannot be retrieved
+ */
+ public static QueryResult query(Session session, String query,
+ String language, long offset, long limit) throws RepositoryException {
QueryManager qManager = session.getWorkspace().getQueryManager();
Query q = qManager.createQuery(query, language);
+ q.setOffset(offset);
+ q.setLimit(limit);
return q.execute();
}
diff --git a/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/BasicQueryLanguageProvider.java b/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/BasicQueryLanguageProvider.java
index 35f9849..5acf880 100644
--- a/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/BasicQueryLanguageProvider.java
+++ b/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/BasicQueryLanguageProvider.java
@@ -63,6 +63,10 @@
this.providerContext = ctx;
}
+ protected QueryResult query(final ResolveContext<JcrProviderState> ctx, final String query, final String language) throws RepositoryException{
+ return JcrResourceUtil.query(ctx.getProviderState().getSession(), query, language);
+ }
+
@Override
public String[] getSupportedLanguages(final ResolveContext<JcrProviderState> ctx) {
try {
@@ -77,7 +81,7 @@
final String query,
final String language) {
try {
- final QueryResult res = JcrResourceUtil.query(ctx.getProviderState().getSession(), query, language);
+ final QueryResult res = query(ctx, query, language);
return new JcrNodeResourceIterator(ctx.getResourceResolver(),
null, null,
res.getNodes(),
@@ -97,7 +101,7 @@
final String queryLanguage = ArrayUtils.contains(getSupportedLanguages(ctx), language) ? language : DEFAULT_QUERY_LANGUAGE;
try {
- final QueryResult result = JcrResourceUtil.query(ctx.getProviderState().getSession(), query, queryLanguage);
+ final QueryResult result = query(ctx, query, queryLanguage);
final String[] colNames = result.getColumnNames();
final RowIterator rows = result.getRows();
diff --git a/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/JcrResourceProvider.java b/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/JcrResourceProvider.java
index bdb7790..d7809d6 100644
--- a/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/JcrResourceProvider.java
+++ b/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/JcrResourceProvider.java
@@ -32,8 +32,6 @@
import java.util.TreeMap;
import java.util.concurrent.atomic.AtomicReference;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.annotations.NotNull;
import javax.jcr.Item;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
@@ -64,6 +62,8 @@
import org.apache.sling.spi.resource.provider.ResolveContext;
import org.apache.sling.spi.resource.provider.ResourceContext;
import org.apache.sling.spi.resource.provider.ResourceProvider;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
import org.osgi.framework.Constants;
import org.osgi.framework.ServiceReference;
import org.osgi.service.component.ComponentContext;
@@ -73,6 +73,9 @@
import org.osgi.service.component.annotations.Reference;
import org.osgi.service.component.annotations.ReferenceCardinality;
import org.osgi.service.component.annotations.ReferencePolicy;
+import org.osgi.service.metatype.annotations.AttributeDefinition;
+import org.osgi.service.metatype.annotations.Designate;
+import org.osgi.service.metatype.annotations.ObjectClassDefinition;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -88,6 +91,7 @@
ResourceProvider.PROPERTY_AUTHENTICATE + "=" + ResourceProvider.AUTHENTICATE_REQUIRED,
Constants.SERVICE_VENDOR + "=The Apache Software Foundation"
})
+@Designate(ocd = JcrResourceProvider.Config.class)
public class JcrResourceProvider extends ResourceProvider<JcrProviderState> {
/** Logger */
@@ -103,6 +107,16 @@
IGNORED_PROPERTIES.add("jcr:createdBy");
}
+ @ObjectClassDefinition(name = "Apache Sling JCR Resource Provider", description = "Provides Sling resources based on the Java Content Repository")
+ public @interface Config {
+
+ @AttributeDefinition(name = "Enable Query Limit", description = "If set to true, the JcrResourceProvider will support parsing query start and limits from comments in the queries and set a default limit for all other queries using the findResources methods")
+ boolean enable_query_limit() default false;
+
+ @AttributeDefinition(name = "Default Query Limit", description = "The default query limit for queries using the findResources methods")
+ long default_query_limit() default 10000L;
+ }
+
@Reference(name = REPOSITORY_REFERENCE_NAME, service = SlingRepository.class)
private ServiceReference<SlingRepository> repositoryReference;
@@ -122,12 +136,14 @@
private volatile JcrProviderStateFactory stateFactory;
+ private Config config;
+
private final AtomicReference<DynamicClassLoaderManager> classLoaderManagerReference = new AtomicReference<>();
private AtomicReference<URIProvider[]> uriProviderReference = new AtomicReference<>();
@Activate
- protected void activate(final ComponentContext context) {
+ protected void activate(final ComponentContext context, final Config config) throws RepositoryException {
SlingRepository repository = context.locateService(REPOSITORY_REFERENCE_NAME,
this.repositoryReference);
if (repository == null) {
@@ -138,6 +154,8 @@
return;
}
+ this.config = config;
+
this.repository = repository;
this.stateFactory = new JcrProviderStateFactory(repositoryReference, repository,
@@ -634,6 +652,9 @@
public @Nullable QueryLanguageProvider<JcrProviderState> getQueryLanguageProvider() {
final ProviderContext ctx = this.getProviderContext();
if ( ctx != null ) {
+ if(config.enable_query_limit()){
+ return new LimitingQueryLanguageProvider(ctx, config.default_query_limit());
+ }
return new BasicQueryLanguageProvider(ctx);
}
return null;
diff --git a/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/LimitingQueryLanguageProvider.java b/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/LimitingQueryLanguageProvider.java
new file mode 100644
index 0000000..be86ae6
--- /dev/null
+++ b/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/LimitingQueryLanguageProvider.java
@@ -0,0 +1,129 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.sling.jcr.resource.internal.helper.jcr;
+
+import java.io.IOException;
+import java.io.StreamTokenizer;
+import java.io.StringReader;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import javax.jcr.RepositoryException;
+import javax.jcr.query.QueryResult;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.ImmutableTriple;
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.commons.lang3.tuple.Triple;
+import org.apache.sling.jcr.resource.internal.helper.JcrResourceUtil;
+import org.apache.sling.spi.resource.provider.ProviderContext;
+import org.apache.sling.spi.resource.provider.ResolveContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class LimitingQueryLanguageProvider extends BasicQueryLanguageProvider {
+
+ private final Logger log = LoggerFactory.getLogger(LimitingQueryLanguageProvider.class);
+
+ /** The limit to set for queries */
+ private final long defaultLimit;
+
+ public LimitingQueryLanguageProvider(final ProviderContext ctx, long defaultLimit) {
+ super(ctx);
+ this.defaultLimit = defaultLimit;
+ }
+
+ @Override
+ protected QueryResult query(final ResolveContext<JcrProviderState> ctx, final String query, final String language)
+ throws RepositoryException {
+ Triple<String, Long, Long> settings = extractQuerySettings(query);
+ return JcrResourceUtil.query(ctx.getProviderState().getSession(), settings.getLeft(), language,
+ settings.getMiddle(), settings.getRight());
+ }
+
+ protected Triple<String, Long, Long> extractQuerySettings(String query) {
+ query = query.trim();
+ if (query.endsWith("*/")) {
+ Pair<Long, Long> settings = parseQueryComment(
+ query.substring(query.lastIndexOf("/*") + 2, query.lastIndexOf("*/")));
+ return new ImmutableTriple<>(query.substring(0, query.lastIndexOf("/*")),
+ settings.getLeft(), settings.getRight());
+ } else {
+ return new ImmutableTriple<>(query, 0L, defaultLimit);
+ }
+ }
+
+ private Pair<Long, Long> parseQueryComment(String query) {
+ Map<String, Object> parsed = new HashMap<>();
+ StreamTokenizer tokenizer = new StreamTokenizer(new StringReader(query));
+ int currentToken;
+ try {
+ currentToken = tokenizer.nextToken();
+ boolean key = true;
+ Object current = null;
+ while (currentToken != StreamTokenizer.TT_EOF) {
+ if (tokenizer.ttype == StreamTokenizer.TT_NUMBER) {
+ if (!key) {
+ parsed.put((String) current, tokenizer.nval);
+ key = true;
+ current = null;
+ } else {
+ throw new IOException(
+ "Encountered unexpected numeric key: " + tokenizer.toString());
+ }
+ } else if (tokenizer.ttype == StreamTokenizer.TT_WORD) {
+ if (!key) {
+ parsed.put((String) current, tokenizer.nval);
+ key = true;
+ } else if (current == null) {
+ current = tokenizer.sval;
+ } else {
+ throw new IOException(
+ "Encountered unmatched key value pair: " + tokenizer.toString());
+ }
+ } else if (((char) currentToken) == '=') {
+ key = false;
+ } else if (((char) currentToken) == ',' || ((char) currentToken) == ';') {
+ // nothing really required, just ignoring as it's a separator
+ } else {
+ throw new IOException(
+ "Encountered unexpected character parsing query comment: " + tokenizer.toString());
+ }
+ currentToken = tokenizer.nextToken();
+ }
+ } catch (Exception e) {
+ log.warn("Failed to parse query comment due to exception: {}", e.toString());
+ return new ImmutablePair<>(0L, defaultLimit);
+ }
+ return new ImmutablePair<>(getKeyAsLong(parsed, "slingQueryStart", 0L),
+ getKeyAsLong(parsed, "slingQueryLimit", defaultLimit));
+ }
+
+ private Long getKeyAsLong(Map<String, Object> parsed, String key, Long defaultVal) {
+ return Optional.ofNullable(parsed.get(key)).map(v -> {
+ if (v instanceof String) {
+ return Long.parseLong(v.toString());
+ } else {
+ return ((Double) v).longValue();
+ }
+ }).orElse(defaultVal);
+ }
+
+}
diff --git a/src/test/java/org/apache/sling/jcr/resource/internal/helper/jcr/JcrResourceProviderSessionHandlingTest.java b/src/test/java/org/apache/sling/jcr/resource/internal/helper/jcr/JcrResourceProviderSessionHandlingTest.java
index 5dbdf7c..c52f271 100644
--- a/src/test/java/org/apache/sling/jcr/resource/internal/helper/jcr/JcrResourceProviderSessionHandlingTest.java
+++ b/src/test/java/org/apache/sling/jcr/resource/internal/helper/jcr/JcrResourceProviderSessionHandlingTest.java
@@ -31,6 +31,7 @@
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
@@ -47,6 +48,7 @@
import org.apache.sling.api.resource.ResourceResolverFactory;
import org.apache.sling.jcr.api.SlingRepository;
import org.apache.sling.jcr.resource.api.JcrResourceConstants;
+import org.apache.sling.jcr.resource.internal.helper.jcr.JcrResourceProvider.Config;
import org.apache.sling.spi.resource.provider.ResolveContext;
import org.apache.sling.spi.resource.provider.ResourceProvider;
import org.junit.After;
@@ -235,7 +237,20 @@
when(ctx.locateService(anyString(), Mockito.<ServiceReference<Object>>any())).thenReturn(repo);
jcrResourceProvider = new JcrResourceProvider();
- jcrResourceProvider.activate(ctx);
+ jcrResourceProvider.activate(ctx, new Config() {
+ @Override
+ public Class<? extends Annotation> annotationType() {
+ return null;
+ }
+ @Override
+ public boolean enable_query_limit() {
+ return false;
+ }
+ @Override
+ public long default_query_limit() {
+ return 0;
+ }
+ });
jcrProviderState = jcrResourceProvider.authenticate(authInfo);
}
diff --git a/src/test/java/org/apache/sling/jcr/resource/internal/helper/jcr/JcrResourceProviderTest.java b/src/test/java/org/apache/sling/jcr/resource/internal/helper/jcr/JcrResourceProviderTest.java
index 684ce80..de99546 100644
--- a/src/test/java/org/apache/sling/jcr/resource/internal/helper/jcr/JcrResourceProviderTest.java
+++ b/src/test/java/org/apache/sling/jcr/resource/internal/helper/jcr/JcrResourceProviderTest.java
@@ -18,6 +18,7 @@
*/
package org.apache.sling.jcr.resource.internal.helper.jcr;
+import java.lang.annotation.Annotation;
import java.security.Principal;
import javax.jcr.Node;
@@ -26,9 +27,9 @@
import javax.jcr.Session;
import javax.jcr.nodetype.NodeType;
-import org.apache.jackrabbit.commons.JcrUtils;
import org.apache.sling.api.resource.PersistenceException;
import org.apache.sling.api.resource.Resource;
+import org.apache.sling.jcr.resource.internal.helper.jcr.JcrResourceProvider.Config;
import org.apache.sling.spi.resource.provider.ResolveContext;
import org.apache.sling.spi.resource.provider.ResourceContext;
import org.junit.Assert;
@@ -50,7 +51,20 @@
ComponentContext ctx = Mockito.mock(ComponentContext.class);
Mockito.when(ctx.locateService(Mockito.anyString(), Mockito.any(ServiceReference.class))).thenReturn(repo);
jcrResourceProvider = new JcrResourceProvider();
- jcrResourceProvider.activate(ctx);
+ jcrResourceProvider.activate(ctx, new Config() {
+ @Override
+ public Class<? extends Annotation> annotationType() {
+ return null;
+ }
+ @Override
+ public boolean enable_query_limit() {
+ return false;
+ }
+ @Override
+ public long default_query_limit() {
+ return 0;
+ }
+ });
}
@Override
diff --git a/src/test/java/org/apache/sling/jcr/resource/internal/helper/jcr/LimitingQueryLanguageProviderTest.java b/src/test/java/org/apache/sling/jcr/resource/internal/helper/jcr/LimitingQueryLanguageProviderTest.java
new file mode 100644
index 0000000..77dd127
--- /dev/null
+++ b/src/test/java/org/apache/sling/jcr/resource/internal/helper/jcr/LimitingQueryLanguageProviderTest.java
@@ -0,0 +1,112 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.sling.jcr.resource.internal.helper.jcr;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.apache.commons.lang3.tuple.Triple;
+import org.apache.sling.spi.resource.provider.ProviderContext;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class LimitingQueryLanguageProviderTest {
+
+ @Parameters(name = "{0}")
+ public static Collection<Object[]> testCases() {
+ return Arrays.asList(new Object[][] {
+ testCase("JCR-SQL2 No Settings", "SELECT * FROM [nt:folder]", 10L,
+ "SELECT * FROM [nt:folder]",
+ 0L, 10L),
+ testCase("JCR-SQL2 With Limit", "SELECT * FROM [nt:folder] /* slingQueryLimit=20 */", 10L,
+ "SELECT * FROM [nt:folder] ",
+ 0L, 20L),
+ testCase("JCR-SQL2 With Limit", "SELECT * FROM [nt:folder] /* slingQueryStart=2, slingQueryLimit=20 */",
+ 10L,
+ "SELECT * FROM [nt:folder] ",
+ 2L, 20L),
+ testCase("JCR-SQL2 With Limit", "SELECT * FROM [nt:folder] /* someotherkey=2, slingQueryLimit=20 */",
+ 10L,
+ "SELECT * FROM [nt:folder] ",
+ 0L, 20L),
+ testCase("JCR-SQL2 With Limit", "SELECT * FROM [nt:folder] /* someotherkey=2, slingQueryLimit=20 */",
+ 10L,
+ "SELECT * FROM [nt:folder] ",
+ 0L, 20L),
+ testCase("XPath With Limit",
+ " /jcr:root/content//element(*, sling:Folder)[@sling:resourceType='x'] /* slingQueryStart=2, slingQueryLimit=20 */",
+ 10L,
+ "/jcr:root/content//element(*, sling:Folder)[@sling:resourceType='x'] ",
+ 2L, 20L),
+ testCase("XPath With Invalid Key",
+ " /jcr:root/content//element(*, sling:Folder)[@sling:resourceType='x'] /* 2=2, slingQueryLimit=20 */",
+ 10L,
+ "/jcr:root/content//element(*, sling:Folder)[@sling:resourceType='x'] ",
+ 0L, 10L)
+ });
+ }
+
+ public static Object[] testCase(String name, String query, long defaultLimit, String expectedQuery,
+ long expectedStart,
+ long expectedLimit) {
+ return new Object[] {
+ name, query, defaultLimit, expectedQuery, expectedStart, expectedLimit
+ };
+
+ }
+
+ private String name;
+ private String query;
+ private Long defaultLimit;
+ private String expectedQuery;
+ private Long expectedStart;
+ private Long expectedLimit;
+
+ public LimitingQueryLanguageProviderTest(String name, String query, long defaultLimit,
+ String expectedQuery,
+ long expectedStart,
+ long expectedLimit) {
+ this.name = name;
+ this.query = query;
+ this.defaultLimit = defaultLimit;
+ this.expectedQuery = expectedQuery;
+ this.expectedStart = expectedStart;
+ this.expectedLimit = expectedLimit;
+ }
+
+ @Test
+ public void testQueryLanguageProvider() {
+ LimitingQueryLanguageProvider provider = new LimitingQueryLanguageProvider(mock(ProviderContext.class),
+ defaultLimit);
+
+ Triple<String, Long, Long> settings = provider.extractQuerySettings(query);
+
+ assertEquals(expectedQuery, settings.getLeft());
+ assertEquals(expectedStart, settings.getMiddle());
+ assertEquals(expectedLimit, settings.getRight());
+
+ }
+
+}
