You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@sling.apache.org by ro...@apache.org on 2018/08/17 09:02:12 UTC

[sling-org-apache-sling-resourceresolver] branch feature/SLING-7792 updated (ea63aeb -> 33d2da9)

This is an automated email from the ASF dual-hosted git repository.

rombert pushed a change to branch feature/SLING-7792
in repository https://gitbox.apache.org/repos/asf/sling-org-apache-sling-resourceresolver.git.


    omit ea63aeb  Merge remote-tracking branch 'origin/master' into feature/SLING-7792
    omit 69753b3  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit fc1dadc  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit 2387e26  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit 8c41978  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit 90246e9  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit a8e5517  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit b35fcc8  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit 787540d  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit a382419  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit 07afbd7  Merge remote-tracking branch 'origin/feature/update-testing-deps' into feature/SLING-7792
    omit 5a1517f  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit b236efd  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit 018d29e  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit ce31c41  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit d628ebb  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit e7bbf11  SLING-7792 - Resource Resolver should return more than one resolved path if available
    omit 316164d  SLING-7792 - Resource Resolver should return more than one resolved path if available
     new c64f246  SLING-7792 - Resource Resolver should return more than one resolved path if available
     new 07955b3  SLING-7792 - Resource Resolver should return more than one resolved path if available
     new 33d2da9  SLING-7792 - Resource Resolver should return more than one resolved path if available

This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version.  This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:

 * -- * -- B -- O -- O -- O   (ea63aeb)
            \
             N -- N -- N   refs/heads/feature/SLING-7792 (33d2da9)

You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.

Any revisions marked "omit" are not gone; other references still
refer to them.  Any revisions marked "discard" are gone forever.

The 3 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 .../org/apache/sling/resourceresolver/impl/ResourceResolverImpl.java    | 2 +-
 .../apache/sling/resourceresolver/impl/mapping/ResourceMapperImpl.java  | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)


[sling-org-apache-sling-resourceresolver] 03/03: SLING-7792 - Resource Resolver should return more than one resolved path if available

Posted by ro...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

rombert pushed a commit to branch feature/SLING-7792
in repository https://gitbox.apache.org/repos/asf/sling-org-apache-sling-resourceresolver.git

commit 33d2da96e1d7fee6f67ea46c1c2edec97a7fbd0c
Author: Robert Munteanu <ro...@apache.org>
AuthorDate: Tue Aug 14 16:05:32 2018 +0200

    SLING-7792 - Resource Resolver should return more than one resolved path if available
    
    Add a new ResourceMapperImpl class that contains the logic for fine-grained access to
    resource mappings.
    
    Added a new set of tests that validate that the usage of the various mapping sources
    (aliases, /etc/map) is correct.
    
    This change also opens up some methods from the ResourceResolverImpl, but it looks
    reasonable as they are not exposed outside the bundle.
---
 .../impl/ResourceResolverImpl.java                 | 220 +-----------
 .../impl/mapping/ResourceMapperImpl.java           | 368 +++++++++++++++++++++
 .../impl/mapping/InMemoryResource.java             |  96 ++++++
 .../impl/mapping/InMemoryResourceProvider.java     |  79 +++++
 .../impl/mapping/ResourceMapperImplTest.java       | 267 +++++++++++++++
 5 files changed, 823 insertions(+), 207 deletions(-)

diff --git a/src/main/java/org/apache/sling/resourceresolver/impl/ResourceResolverImpl.java b/src/main/java/org/apache/sling/resourceresolver/impl/ResourceResolverImpl.java
index 4acf759..21ca9c9 100644
--- a/src/main/java/org/apache/sling/resourceresolver/impl/ResourceResolverImpl.java
+++ b/src/main/java/org/apache/sling/resourceresolver/impl/ResourceResolverImpl.java
@@ -25,7 +25,6 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -48,6 +47,7 @@ import org.apache.sling.api.resource.ResourceResolver;
 import org.apache.sling.api.resource.ResourceResolverFactory;
 import org.apache.sling.api.resource.ResourceUtil;
 import org.apache.sling.api.resource.ResourceWrapper;
+import org.apache.sling.api.resource.mapping.ResourceMapper;
 import org.apache.sling.resourceresolver.impl.helper.RedirectResource;
 import org.apache.sling.resourceresolver.impl.helper.ResourceIteratorDecorator;
 import org.apache.sling.resourceresolver.impl.helper.ResourcePathIterator;
@@ -57,13 +57,14 @@ import org.apache.sling.resourceresolver.impl.helper.StarResource;
 import org.apache.sling.resourceresolver.impl.helper.URI;
 import org.apache.sling.resourceresolver.impl.helper.URIException;
 import org.apache.sling.resourceresolver.impl.mapping.MapEntry;
+import org.apache.sling.resourceresolver.impl.mapping.ResourceMapperImpl;
 import org.apache.sling.resourceresolver.impl.params.ParsedParameters;
 import org.apache.sling.resourceresolver.impl.providers.ResourceProviderStorageProvider;
 import org.apache.sling.spi.resource.provider.ResourceProvider;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-@Adaptable(adaptableClass = ResourceResolver.class, adapters = { @Adapter(Session.class) })
+@Adaptable(adaptableClass = ResourceResolver.class, adapters = { @Adapter(Session.class), @Adapter(ResourceMapper.class) })
 public class ResourceResolverImpl extends SlingAdaptable implements ResourceResolver {
 
     /** Default logger */
@@ -79,7 +80,7 @@ public class ResourceResolverImpl extends SlingAdaptable implements ResourceReso
     // such as nt:file. The slash is included to prevent false
     // positives for the String.endsWith check for names like
     // "xyzjcr:content"
-    private static final String JCR_CONTENT_LEAF = "/jcr:content";
+    public static final String JCR_CONTENT_LEAF = "/jcr:content";
 
     /** The factory which created this resource resolver. */
     private final CommonResourceResolverFactoryImpl factory;
@@ -181,7 +182,7 @@ public class ResourceResolverImpl extends SlingAdaptable implements ResourceReso
      * @throws IllegalStateException
      *             If the resolver is already closed or the factory is no longer live.
      */
-    private void checkClosed() {
+    public void checkClosed() {
         if (this.control.isClosed()) {
             if (closedResolverException != null) {
                 logger.error("The ResourceResolver has already been closed.", closedResolverException);
@@ -415,200 +416,7 @@ public class ResourceResolverImpl extends SlingAdaptable implements ResourceReso
      */
     @Override
     public String map(final HttpServletRequest request, final String resourcePath) {
-        checkClosed();
-
-        // find a fragment or query
-        int fragmentQueryMark = resourcePath.indexOf('#');
-        if (fragmentQueryMark < 0) {
-            fragmentQueryMark = resourcePath.indexOf('?');
-        }
-
-        // cut fragment or query off the resource path
-        String mappedPath;
-        final String fragmentQuery;
-        if (fragmentQueryMark >= 0) {
-            fragmentQuery = resourcePath.substring(fragmentQueryMark);
-            mappedPath = resourcePath.substring(0, fragmentQueryMark);
-            logger.debug("map: Splitting resource path '{}' into '{}' and '{}'", new Object[] { resourcePath, mappedPath,
-                    fragmentQuery });
-        } else {
-            fragmentQuery = null;
-            mappedPath = resourcePath;
-        }
-
-        // cut off scheme and host, if the same as requested
-        final String schemehostport;
-        final String schemePrefix;
-        if (request != null) {
-            schemehostport = MapEntry.getURI(request.getScheme(), request.getServerName(), request.getServerPort(), "/");
-            schemePrefix = request.getScheme().concat("://");
-            logger.debug("map: Mapping path {} for {} (at least with scheme prefix {})", new Object[] { resourcePath,
-                    schemehostport, schemePrefix });
-
-        } else {
-
-            schemehostport = null;
-            schemePrefix = null;
-            logger.debug("map: Mapping path {} for default", resourcePath);
-
-        }
-
-        ParsedParameters parsed = new ParsedParameters(mappedPath);
-        final Resource nonDecoratedResource = resolveInternal(parsed.getRawPath(), parsed.getParameters());
-
-        if (nonDecoratedResource != null) {
-
-            //Invoke the decorator for the resolved resource
-            Resource res=this.factory.getResourceDecoratorTracker().decorate(nonDecoratedResource);
-
-            // keep, what we might have cut off in internal resolution
-            final String resolutionPathInfo = res.getResourceMetadata().getResolutionPathInfo();
-
-            logger.debug("map: Path maps to resource {} with path info {}", res, resolutionPathInfo);
-
-            // find aliases for segments. we can't walk the parent chain
-            // since the request session might not have permissions to
-            // read all parents SLING-2093
-            final LinkedList<String> names = new LinkedList<>();
-
-            Resource current = res;
-            String path = res.getPath();
-            while (path != null) {
-                String alias = null;
-                if (current != null && !path.endsWith(JCR_CONTENT_LEAF)) {
-                    if (factory.isOptimizeAliasResolutionEnabled()) {
-                        logger.debug("map: Optimize Alias Resolution is Enabled");
-                        String parentPath = ResourceUtil.getParent(path);
-                        if (parentPath != null) {
-                            final Map<String, String> aliases = factory.getMapEntries().getAliasMap(parentPath);
-                            if (aliases!= null && aliases.containsValue(current.getName())) {
-                                for (String key:aliases.keySet()) {
-                                    if (current.getName().equals(aliases.get(key))) {
-                                        alias = key;
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                    } else {
-                        logger.debug("map: Optimize Alias Resolution is Disabled");
-                        alias = ResourceResolverControl.getProperty(current, PROP_ALIAS);
-                    }
-                }
-                if (alias == null || alias.length() == 0) {
-                    alias = ResourceUtil.getName(path);
-                }
-                names.add(alias);
-                path = ResourceUtil.getParent(path);
-                if ("/".equals(path)) {
-                    path = null;
-                } else if (path != null) {
-                    current = res.getResourceResolver().resolve(path);
-                }
-            }
-
-            // build path from segment names
-            final StringBuilder buf = new StringBuilder();
-
-            // construct the path from the segments (or root if none)
-            if (names.isEmpty()) {
-                buf.append('/');
-            } else {
-                while (!names.isEmpty()) {
-                    buf.append('/');
-                    buf.append(names.removeLast());
-                }
-            }
-
-            // reappend the resolutionPathInfo
-            if (resolutionPathInfo != null) {
-                buf.append(resolutionPathInfo);
-            }
-
-            // and then we have the mapped path to work on
-            mappedPath = buf.toString();
-
-            logger.debug("map: Alias mapping resolves to path {}", mappedPath);
-
-        }
-
-        boolean mappedPathIsUrl = false;
-        for (final MapEntry mapEntry : this.factory.getMapEntries().getMapMaps()) {
-            final String[] mappedPaths = mapEntry.replace(mappedPath);
-            if (mappedPaths != null) {
-
-                logger.debug("map: Match for Entry {}", mapEntry);
-
-                mappedPathIsUrl = !mapEntry.isInternal();
-
-                if (mappedPathIsUrl && schemehostport != null) {
-
-                    mappedPath = null;
-
-                    for (final String candidate : mappedPaths) {
-                        if (candidate.startsWith(schemehostport)) {
-                            mappedPath = candidate.substring(schemehostport.length() - 1);
-                            mappedPathIsUrl = false;
-                            logger.debug("map: Found host specific mapping {} resolving to {}", candidate, mappedPath);
-                            break;
-                        } else if (candidate.startsWith(schemePrefix) && mappedPath == null) {
-                            mappedPath = candidate;
-                        }
-                    }
-
-                    if (mappedPath == null) {
-                        mappedPath = mappedPaths[0];
-                    }
-
-                } else {
-
-                    // we can only go with assumptions selecting the first entry
-                    mappedPath = mappedPaths[0];
-
-                }
-
-                logger.debug("map: MapEntry {} matches, mapped path is {}", mapEntry, mappedPath);
-
-                break;
-            }
-        }
-
-        // this should not be the case, since mappedPath is primed
-        if (mappedPath == null) {
-            mappedPath = resourcePath;
-        }
-
-        // [scheme:][//authority][path][?query][#fragment]
-        try {
-            // use commons-httpclient's URI instead of java.net.URI, as it can
-            // actually accept *unescaped* URIs, such as the "mappedPath" and
-            // return them in proper escaped form, including the path, via
-            // toString()
-            final URI uri = new URI(mappedPath, false);
-
-            // 1. mangle the namespaces in the path
-            String path = mangleNamespaces(uri.getPath());
-
-            // 2. prepend servlet context path if we have a request
-            if (request != null && request.getContextPath() != null && request.getContextPath().length() > 0) {
-                path = request.getContextPath().concat(path);
-            }
-            // update the path part of the URI
-            uri.setPath(path);
-
-            mappedPath = uri.toString();
-        } catch (final URIException e) {
-            logger.warn("map: Unable to mangle namespaces for " + mappedPath + " returning unmangled", e);
-        }
-
-        logger.debug("map: Returning URL {} as mapping for path {}", mappedPath, resourcePath);
-
-        // reappend fragment and/or query
-        if (fragmentQuery != null) {
-            mappedPath = mappedPath.concat(fragmentQuery);
-        }
-
-        return mappedPath;
+        return adaptTo(ResourceMapper.class).getMapping(resourcePath, request);
     }
 
     // ---------- search path for relative resoures
@@ -805,6 +613,7 @@ public class ResourceResolverImpl extends SlingAdaptable implements ResourceReso
     /**
      * @see org.apache.sling.api.adapter.SlingAdaptable#adaptTo(java.lang.Class)
      */
+    @SuppressWarnings("unchecked")
     @Override
     public <AdapterType> AdapterType adaptTo(final Class<AdapterType> type) {
         checkClosed();
@@ -812,6 +621,11 @@ public class ResourceResolverImpl extends SlingAdaptable implements ResourceReso
         if (type.getName().equals("javax.jcr.Session")) {
             return getSession(type);
         }
+        
+        if ( type == ResourceMapper.class )
+            return (AdapterType) new ResourceMapperImpl(this, factory.getResourceDecoratorTracker(), factory.getMapEntries(), 
+                    factory.isOptimizeAliasResolutionEnabled(), factory.getNamespaceMangler());
+        
         final AdapterType result = this.control.adaptTo(this.context, type);
         if ( result != null ) {
             return result;
@@ -873,7 +687,7 @@ public class ResourceResolverImpl extends SlingAdaptable implements ResourceReso
      *         the part of the <code>absPath</code> which has been cut off by
      *         the {@link ResourcePathIterator} to resolve the resource.
      */
-    private Resource resolveInternal(final String absPath, final Map<String, String> parameters) {
+    public Resource resolveInternal(final String absPath, final Map<String, String> parameters) {
         Resource resource = null;
         String curPath = absPath;
         try {
@@ -1102,14 +916,6 @@ public class ResourceResolverImpl extends SlingAdaptable implements ResourceReso
         return path;
     }
 
-    private String mangleNamespaces(String absPath) {
-        if ( absPath != null && factory.getNamespaceMangler() != null ) {
-            absPath = ((JcrNamespaceMangler)factory.getNamespaceMangler()).mangleNamespaces(this, logger, absPath);
-        }
-
-        return absPath;
-    }
-
     private String unmangleNamespaces(String absPath) {
         if (absPath != null && factory.getNamespaceMangler() != null ) {
             absPath = ((JcrNamespaceMangler)factory.getNamespaceMangler()).unmangleNamespaces(this, logger, absPath);
diff --git a/src/main/java/org/apache/sling/resourceresolver/impl/mapping/ResourceMapperImpl.java b/src/main/java/org/apache/sling/resourceresolver/impl/mapping/ResourceMapperImpl.java
new file mode 100644
index 0000000..5610054
--- /dev/null
+++ b/src/main/java/org/apache/sling/resourceresolver/impl/mapping/ResourceMapperImpl.java
@@ -0,0 +1,368 @@
+/*
+ * 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.resourceresolver.impl.mapping;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.UnaryOperator;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.api.resource.ResourceUtil;
+import org.apache.sling.api.resource.mapping.ResourceMapper;
+import org.apache.sling.resourceresolver.impl.JcrNamespaceMangler;
+import org.apache.sling.resourceresolver.impl.ResourceResolverImpl;
+import org.apache.sling.resourceresolver.impl.helper.ResourceDecoratorTracker;
+import org.apache.sling.resourceresolver.impl.helper.ResourceResolverControl;
+import org.apache.sling.resourceresolver.impl.helper.URI;
+import org.apache.sling.resourceresolver.impl.helper.URIException;
+import org.apache.sling.resourceresolver.impl.params.ParsedParameters;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ResourceMapperImpl implements ResourceMapper {
+    
+    private final Logger logger = LoggerFactory.getLogger(getClass());
+
+    private final ResourceResolverImpl resolver;
+    private final ResourceDecoratorTracker resourceDecorator;
+    private final MapEntriesHandler mapEntries;
+    private final boolean optimizedAliasResolutionEnabled;
+    private final Object namespaceMangler;
+    
+
+    public ResourceMapperImpl(ResourceResolverImpl resolver, ResourceDecoratorTracker resourceDecorator, 
+            MapEntriesHandler mapEntries, boolean optimizedAliasResolutionEnabled, Object namespaceMangler) {
+        this.resolver = resolver;
+        this.resourceDecorator = resourceDecorator;
+        this.mapEntries = mapEntries;
+        this.optimizedAliasResolutionEnabled = optimizedAliasResolutionEnabled;
+        this.namespaceMangler = namespaceMangler;
+    }
+
+    @Override
+    public String getMapping(String resourcePath) {
+        return getMapping(resourcePath, null);
+    }
+
+    @Override
+    public String getMapping(String resourcePath, HttpServletRequest request) {
+        
+        Collection<String> mappings = getAllMappings(resourcePath, request);
+        if ( mappings.isEmpty() )
+            return null;
+        
+        return mappings.iterator().next();
+    }
+
+    @Override
+    public Collection<String> getAllMappings(String resourcePath) {
+        return getAllMappings(resourcePath, null);
+    }
+
+    @Override
+    public Collection<String> getAllMappings(String resourcePath, HttpServletRequest request) {
+        
+        resolver.checkClosed();
+        
+        List<String> mappings = new ArrayList<>();
+        
+        // 1. parse parameters
+        
+        // find a fragment or query
+        int fragmentQueryMark = resourcePath.indexOf('#');
+        if (fragmentQueryMark < 0) {
+            fragmentQueryMark = resourcePath.indexOf('?');
+        }
+
+        // cut fragment or query off the resource path
+        String mappedPath;
+        final String fragmentQuery;
+        if (fragmentQueryMark >= 0) {
+            fragmentQuery = resourcePath.substring(fragmentQueryMark);
+            mappedPath = resourcePath.substring(0, fragmentQueryMark);
+            logger.debug("map: Splitting resource path '{}' into '{}' and '{}'", new Object[] { resourcePath, mappedPath,
+                    fragmentQuery });
+        } else {
+            fragmentQuery = null;
+            mappedPath = resourcePath;
+        }
+
+        final RequestContext requestContext = new RequestContext(request, resourcePath);
+        ParsedParameters parsed = new ParsedParameters(mappedPath);
+        
+        // 2. add the requested path itself
+        mappings.add(mappedPath);
+
+        
+        // 3. load aliases
+        final Resource nonDecoratedResource = resolver.resolveInternal(parsed.getRawPath(), parsed.getParameters());
+        if (nonDecoratedResource != null) {
+            loadAliasIfApplicable(mappings, nonDecoratedResource);
+        }
+
+        // 4. load /etc/map entries
+        // populate entries from all entries, including original path and any found aliases
+        for ( String mapped : new ArrayList<>(mappings) )
+            populateMappingsFromMapEntries(mappings, mapped, requestContext);
+
+        
+        // 5. apply context path if needed
+        mappings.replaceAll(new ApplyContextPath(request));
+       
+        // 6. set back the fragment query if needed
+        if ( fragmentQuery != null ) {
+            mappings.replaceAll(new UnaryOperator<String>() {
+                @Override
+                public String apply(String mappedPath) {
+                        return mappedPath.concat(fragmentQuery);
+                }
+            });
+        }
+
+        mappings.forEach( path -> {
+            logger.debug("map: Returning URL {} as mapping for path {}", path, resourcePath);    
+        });
+        
+        
+        // The API contract of the ResourceMapper does not specify the order in which the elements are returned
+        // As an implementation detail however the getMapping method picks the first element of the return value
+        // as the 'winner'.
+        //
+        // Therefore we reverse the sorting to preserve the logic of the old ResourceResolver.map() method (last
+        // found wins) and also make sure that no duplicates are added
+        //
+        // There is some room for improvement here by using a data structure that does not need reversing ( ArrayList
+        // .add moves the elements every time ) or reversal of duplicates but the expectation is that we have a small
+        // number of mappings ( <= 10 ) so the time spent here should be negligible.
+        
+        Collections.reverse(mappings);
+        
+        return new LinkedHashSet<>(mappings);
+    }
+
+    private void loadAliasIfApplicable(List<String> mappings, final Resource nonDecoratedResource) {
+        //Invoke the decorator for the resolved resource
+        Resource res = resourceDecorator.decorate(nonDecoratedResource);
+
+        // keep, what we might have cut off in internal resolution
+        final String resolutionPathInfo = res.getResourceMetadata().getResolutionPathInfo();
+
+        logger.debug("map: Path maps to resource {} with path info {}", res, resolutionPathInfo);
+
+        // find aliases for segments. we can't walk the parent chain
+        // since the request session might not have permissions to
+        // read all parents SLING-2093
+        final LinkedList<String> names = new LinkedList<>();
+
+        Resource current = res;
+        String path = res.getPath();
+        while (path != null) {
+            String alias = null;
+            if (current != null && !path.endsWith(ResourceResolverImpl.JCR_CONTENT_LEAF)) {
+                if (optimizedAliasResolutionEnabled) {
+                    logger.debug("map: Optimize Alias Resolution is Enabled");
+                    String parentPath = ResourceUtil.getParent(path);
+                    if (parentPath != null) {
+                        final Map<String, String> aliases = mapEntries.getAliasMap(parentPath);
+                        if (aliases!= null && aliases.containsValue(current.getName())) {
+                            for (String key:aliases.keySet()) {
+                                if (current.getName().equals(aliases.get(key))) {
+                                    alias = key;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    logger.debug("map: Optimize Alias Resolution is Disabled");
+                    alias = ResourceResolverControl.getProperty(current, ResourceResolverImpl.PROP_ALIAS);
+                }
+            }
+            if (alias == null || alias.length() == 0) {
+                alias = ResourceUtil.getName(path);
+            }
+            names.add(alias);
+            path = ResourceUtil.getParent(path);
+            if ("/".equals(path)) {
+                path = null;
+            } else if (path != null) {
+                current = res.getResourceResolver().resolve(path);
+            }
+        }
+
+        // build path from segment names
+        final StringBuilder buf = new StringBuilder();
+
+        // construct the path from the segments (or root if none)
+        if (names.isEmpty()) {
+            buf.append('/');
+        } else {
+            while (!names.isEmpty()) {
+                buf.append('/');
+                buf.append(names.removeLast());
+            }
+        }
+
+        // reappend the resolutionPathInfo
+        if (resolutionPathInfo != null) {
+            buf.append(resolutionPathInfo);
+        }
+
+        // and then we have the mapped path to work on
+        String mappedPath = buf.toString();
+
+        logger.debug("map: Alias mapping resolves to path {}", mappedPath);
+        
+        mappings.add(mappedPath);
+    }
+
+    private void populateMappingsFromMapEntries(List<String> mappings, String mappedPath,
+            final RequestContext requestContext) {
+        boolean mappedPathIsUrl = false;
+        for (final MapEntry mapEntry : mapEntries.getMapMaps()) {
+            final String[] mappedPaths = mapEntry.replace(mappedPath);
+            if (mappedPaths != null) {
+
+                logger.debug("map: Match for Entry {}", mapEntry);
+
+                mappedPathIsUrl = !mapEntry.isInternal();
+
+                if (mappedPathIsUrl && requestContext.hasUri() ) {
+
+                    mappedPath = null;
+
+                    for (final String candidate : mappedPaths) {
+                        if (candidate.startsWith(requestContext.getUri())) {
+                            mappedPath = candidate.substring(requestContext.getUri().length() - 1);
+                            mappedPathIsUrl = false;
+                            logger.debug("map: Found host specific mapping {} resolving to {}", candidate, mappedPath);
+                            break;
+                        } else if (candidate.startsWith(requestContext.getSchemeWithPrefix()) && mappedPath == null) {
+                            mappedPath = candidate;
+                        }
+                    }
+
+                    if (mappedPath == null) {
+                        mappedPath = mappedPaths[0];
+                    }
+
+                } else {
+
+                    // we can only go with assumptions selecting the first entry
+                    mappedPath = mappedPaths[0];
+
+                }
+
+                logger.debug("map: MapEntry {} matches, mapped path is {}", mapEntry, mappedPath);
+                
+                mappings.add(mappedPath);
+
+                break;
+            }
+        }
+    }
+    
+    private String mangleNamespaces(String absPath) {
+        if ( absPath != null && namespaceMangler != null && namespaceMangler instanceof JcrNamespaceMangler ) {
+            absPath = ((JcrNamespaceMangler) namespaceMangler).mangleNamespaces(resolver, logger, absPath);
+        }
+
+        return absPath;
+    }
+    
+    private class RequestContext {
+        
+        private final String uri;
+        private final String schemeWithPrefix;
+        
+        private RequestContext(HttpServletRequest request, String resourcePath) {
+            if ( request != null ) {
+                this.uri = MapEntry.getURI(request.getScheme(), request.getServerName(), request.getServerPort(), "/");
+                this.schemeWithPrefix = request.getScheme().concat("://");
+                logger.debug("map: Mapping path {} for {} (at least with scheme prefix {})", new Object[] { resourcePath,
+                        uri, schemeWithPrefix });
+            } else {
+                this.uri = null;
+                this.schemeWithPrefix = null;
+                logger.debug("map: Mapping path {} for default", resourcePath);
+            }
+            
+        }
+        
+        public String getUri() {
+            return uri;
+        }
+        
+        public String getSchemeWithPrefix() {
+            return schemeWithPrefix;
+        }
+        
+        public boolean hasUri() {
+            return uri != null && schemeWithPrefix != null;
+        }
+    }
+    
+    private class ApplyContextPath implements UnaryOperator<String> {
+        
+        private final HttpServletRequest req;
+        
+        private ApplyContextPath(HttpServletRequest req) {
+            this.req = req;
+        }
+
+        @Override
+        public String apply(String path) {
+            
+            String mappedPath = path;
+            
+            // [scheme:][//authority][path][?query][#fragment]
+            try {
+                // use commons-httpclient's URI instead of java.net.URI, as it can
+                // actually accept *unescaped* URIs, such as the "mappedPath" and
+                // return them in proper escaped form, including the path, via
+                // toString()
+                final URI uri = new URI(path, false);
+
+                // 1. mangle the namespaces in the path
+                path = mangleNamespaces(uri.getPath());
+
+                // 2. prepend servlet context path if we have a request
+                if (req != null && req.getContextPath() != null && req.getContextPath().length() > 0) {
+                    path = req.getContextPath().concat(path);
+                }
+                // update the path part of the URI
+                uri.setPath(path);
+
+                mappedPath = uri.toString();
+            } catch (final URIException e) {
+                logger.warn("map: Unable to mangle namespaces for " + mappedPath + " returning unmangled", e);
+            }
+
+            return mappedPath;
+        }
+        
+    }
+}
diff --git a/src/test/java/org/apache/sling/resourceresolver/impl/mapping/InMemoryResource.java b/src/test/java/org/apache/sling/resourceresolver/impl/mapping/InMemoryResource.java
new file mode 100644
index 0000000..9792ca9
--- /dev/null
+++ b/src/test/java/org/apache/sling/resourceresolver/impl/mapping/InMemoryResource.java
@@ -0,0 +1,96 @@
+/*
+ * 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.resourceresolver.impl.mapping;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.sling.api.resource.AbstractResource;
+import org.apache.sling.api.resource.ResourceMetadata;
+import org.apache.sling.api.resource.ResourceResolver;
+import org.apache.sling.api.resource.ValueMap;
+import org.apache.sling.api.wrappers.ValueMapDecorator;
+
+public class InMemoryResource extends AbstractResource {
+        
+        private final String path;
+        private final ResourceMetadata metadata;
+        private final ResourceResolver resolver;
+        private final Map<String, Object> properties = new HashMap<>();
+
+        public InMemoryResource(String path, ResourceResolver resolver, Map<String, Object> properties) {
+            
+            if ( path == null )
+                throw new IllegalArgumentException("path is null");
+            
+            if ( resolver == null )
+                throw new IllegalArgumentException("resovler is null");
+            
+            this.path = path;
+            this.metadata = new ResourceMetadata();
+            this.metadata.setResolutionPath(path);;
+            this.resolver = resolver;
+            this.properties.putAll(properties);
+        }
+
+        @Override
+        public String getPath() {
+            return path;
+        }
+
+        @Override
+        public String getResourceType() {
+            return getValueMap().get("sling:resourceType", String.class);
+        }
+
+        @Override
+        public String getResourceSuperType() {
+            return getValueMap().get("sling:resourceSuperType", String.class);
+        }
+
+        @Override
+        public ResourceMetadata getResourceMetadata() {
+            return metadata;
+        }
+
+        @Override
+        public ResourceResolver getResourceResolver() {
+            return resolver;
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public <AdapterType> AdapterType adaptTo(Class<AdapterType> type) {
+            if(type == ValueMap.class || type == Map.class) {
+                return (AdapterType) new ValueMapDecorator(properties);
+            }
+            return super.adaptTo(type);
+        }
+        
+        public InMemoryResource set(String prop, Object val) {
+            properties.put(prop, val);
+            
+            return this;
+        }
+        
+        @Override
+        public String toString() {
+            return getClass().getSimpleName() + " : [ path = " + path + " ]";
+        }
+}
\ No newline at end of file
diff --git a/src/test/java/org/apache/sling/resourceresolver/impl/mapping/InMemoryResourceProvider.java b/src/test/java/org/apache/sling/resourceresolver/impl/mapping/InMemoryResourceProvider.java
new file mode 100644
index 0000000..956a25d
--- /dev/null
+++ b/src/test/java/org/apache/sling/resourceresolver/impl/mapping/InMemoryResourceProvider.java
@@ -0,0 +1,79 @@
+/*
+ * 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.resourceresolver.impl.mapping;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.api.resource.ResourceUtil;
+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.osgi.service.component.annotations.Component;
+
+@Component(service = ResourceProvider.class)
+public class InMemoryResourceProvider extends ResourceProvider<Void> {
+    
+    private final Map<String, Map<String, Object>> resources = new HashMap<>();
+
+    @Override
+    public Resource getResource(ResolveContext<Void> ctx, String path, ResourceContext resourceContext,
+            Resource parent) {
+        
+        Map<String, Object> vals = resources.get(path);
+        if ( vals == null )
+            return null;
+        
+        return new InMemoryResource(path, ctx.getResourceResolver(), vals);
+            
+    }
+
+    @Override
+    public Iterator<Resource> listChildren(ResolveContext<Void> ctx, Resource parent) {
+
+        return resources.entrySet().stream()
+            .filter( e -> parent.getPath().equals(ResourceUtil.getParent(e.getKey())) )
+            .map( e -> (Resource) new InMemoryResource(e.getKey(), ctx.getResourceResolver(), e.getValue()) )
+            .iterator();
+    }
+    
+    public void putResource(String path) {
+        putResource(path, Collections.emptyMap());
+    }
+
+    public void putResource(String path, String key, Object value) {
+        putResource(path, Collections.singletonMap(key, value));
+    }
+
+    public void putResource(String path, String key, Object value, String key2, Object value2) {
+        Map<String, Object> props = new HashMap<>();
+        props.put(key, value);
+        props.put(key2, value2);
+        putResource(path, props);
+    }
+    
+    public void putResource(String path, Map<String, Object> props) {
+        resources.put(path, props);
+    }
+    
+}
\ No newline at end of file
diff --git a/src/test/java/org/apache/sling/resourceresolver/impl/mapping/ResourceMapperImplTest.java b/src/test/java/org/apache/sling/resourceresolver/impl/mapping/ResourceMapperImplTest.java
new file mode 100644
index 0000000..6caefa9
--- /dev/null
+++ b/src/test/java/org/apache/sling/resourceresolver/impl/mapping/ResourceMapperImplTest.java
@@ -0,0 +1,267 @@
+/*
+ * 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.resourceresolver.impl.mapping;
+
+import static org.apache.sling.resourceresolver.impl.ResourceResolverImpl.PROP_ALIAS;
+import static org.apache.sling.spi.resource.provider.ResourceProvider.PROPERTY_NAME;
+import static org.apache.sling.spi.resource.provider.ResourceProvider.PROPERTY_ROOT;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.sling.api.resource.LoginException;
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.api.resource.ResourceResolver;
+import org.apache.sling.api.resource.ResourceResolverFactory;
+import org.apache.sling.api.resource.ResourceUtil;
+import org.apache.sling.api.resource.mapping.ResourceMapper;
+import org.apache.sling.resourceresolver.impl.ResourceAccessSecurityTracker;
+import org.apache.sling.resourceresolver.impl.ResourceResolverFactoryActivator;
+import org.apache.sling.serviceusermapping.impl.ServiceUserMapperImpl;
+import org.apache.sling.spi.resource.provider.ResourceProvider;
+import org.apache.sling.testing.mock.osgi.junit.OsgiContext;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+/**
+ * Validates that the {@link ResourceMapperImpl} correctly queries all sources of mappings
+ * 
+ * <p>This test ensures that in case more than one mappings is possible, for instance:
+ * 
+ * <ol>
+ *   <li>path for an existing resource</li>
+ *   <li>alias</li>
+ *   <li>/etc/map entries</li>
+ * </ol>
+ * 
+ * all are correctly considered and included in the relevant method calls.
+ * </p>
+ * 
+ * <p>This test should not exhaustively test all mapping scenarios, other tests in this
+ * module and the Sling ITs cover that.</p>
+ *
+ */
+public class ResourceMapperImplTest {
+    
+    @Rule
+    public final OsgiContext ctx = new OsgiContext();
+
+    private HttpServletRequest req;
+    private ResourceResolver resolver;
+
+    @Before
+    public void prepare() throws LoginException {
+
+        ctx.registerInjectActivateService(new ServiceUserMapperImpl());
+        ctx.registerInjectActivateService(new ResourceAccessSecurityTracker());
+        
+        InMemoryResourceProvider resourceProvider = new InMemoryResourceProvider();
+        resourceProvider.putResource("/"); // root
+        resourceProvider.putResource("/here"); // regular page
+        resourceProvider.putResource("/there", PROP_ALIAS, "alias-value"); // with alias
+        resourceProvider.putResource("/somewhere", PROP_ALIAS, "alias-value-2"); // with alias and also /etc/map
+        
+        // build /etc/map structure
+        resourceProvider.putResource("/etc");
+        resourceProvider.putResource("/etc/map");
+        resourceProvider.putResource("/etc/map/http");
+        resourceProvider.putResource("/etc/map/http/localhost_any",
+                "sling:internalRedirect", "/somewhere",
+                "sling:match", "localhost.8080/everywhere");
+        
+        // we fake the fact that we are the JCR resource provider since it's the required one
+        ctx.registerService(ResourceProvider.class, resourceProvider, PROPERTY_ROOT, "/", PROPERTY_NAME, "JCR");
+        // disable optimised alias resolution as it relies on JCR queries
+        ctx.registerInjectActivateService(new ResourceResolverFactoryActivator(),
+                "resource.resolver.optimize.alias.resolution", false);
+        
+        ResourceResolverFactory factory = ctx.getService(ResourceResolverFactory.class);
+        
+        assertNotNull(factory);
+        
+        resolver = factory.getResourceResolver(null);
+        
+        req = mock(HttpServletRequest.class);
+        when(req.getScheme()).thenReturn("http");
+        when(req.getServerName()).thenReturn("localhost");
+        when(req.getServerPort()).thenReturn(8080);
+        when(req.getContextPath()).thenReturn("/app");
+    }
+    
+    @After
+    public void cleanup() {
+        if ( resolver != null )
+            resolver.close();
+    }
+    
+    /**
+     * Validates that mappings for a non-existing resource only contain that resource's path
+     * 
+     * @throws LoginException
+     */
+    @Test
+    public void mapNonExistingPath() throws LoginException {
+        
+        ExpectedMappings.nonExistingResource("/not-here")
+            .singleMapping("/not-here")
+            .singleMappingWithRequest("/app/not-here")
+            .allMappings("/not-here")
+            .allMappingsWithRequest("/app/not-here")
+            .verify(resolver, req);
+    }
+    
+    /**
+     * Validates that mappings for an existing resource only contain that resource's path
+     * 
+     * @throws LoginException
+     */
+    @Test
+    public void mapExistingPath() throws LoginException {
+        
+        ExpectedMappings.existingResource("/here")
+            .singleMapping("/here")
+            .singleMappingWithRequest("/app/here")
+            .allMappings("/here")
+            .allMappingsWithRequest("/app/here")
+            .verify(resolver, req);
+    }
+
+    /**
+     * Validates that mappings for a existing resource with an alias contain the alias and the resource's path
+     * 
+     * @throws LoginException
+     */
+    @Test
+    public void mapResourceWithAlias() {
+        
+        ExpectedMappings.existingResource("/there")
+            .singleMapping("/alias-value")
+            .singleMappingWithRequest("/app/alias-value")
+            .allMappings("/alias-value", "/there")
+            .allMappingsWithRequest("/app/alias-value", "/app/there")
+            .verify(resolver, req);
+    }
+
+    /**
+     * Validates that mappings for a existing resource with an alias and /etc/map entry
+     * contain the /etc/map entry, the alias and the resource's path
+     * 
+     * @throws LoginException
+     */    
+    @Test
+    public void mapResourceWithAliasAndEtcMap() {
+        
+        ExpectedMappings.existingResource("/somewhere")
+            .singleMapping("http://localhost:8080/everywhere")
+            .singleMappingWithRequest("/app/everywhere")
+            .allMappings("http://localhost:8080/everywhere", "/alias-value-2", "/somewhere")
+            .allMappingsWithRequest("/app/everywhere","/app/alias-value-2", "/app/somewhere")
+            .verify(resolver, req);
+    }
+
+    static class ExpectedMappings {
+        
+        public static ExpectedMappings existingResource(String path) {
+            return new ExpectedMappings(path, true);
+        }
+        
+        public static ExpectedMappings nonExistingResource(String path) {
+            return new ExpectedMappings(path, false);
+        }
+        
+        private final String path;
+        private final boolean exists;
+        
+        private String singleMapping;
+        private String singleMappingWithRequest;
+        private Set<String> allMappings;
+        private Set<String> allMappingsWithRequest;
+        
+        private ExpectedMappings(String path, boolean exists) {
+            this.path = path;
+            this.exists = exists;
+        }
+
+        public ExpectedMappings singleMapping(String singleMapping) {
+            this.singleMapping = singleMapping;
+            
+            return this;
+        }
+        
+        public ExpectedMappings singleMappingWithRequest(String singleMappingWithRequest) {
+            this.singleMappingWithRequest = singleMappingWithRequest;
+            
+            return this;
+        }
+        
+        public ExpectedMappings allMappings(String... allMappings) {
+            this.allMappings = new HashSet<>(Arrays.asList(allMappings));
+            
+            return this;
+        }
+
+        public ExpectedMappings allMappingsWithRequest(String... allMappingsWithRequest) {
+            this.allMappingsWithRequest = new HashSet<>(Arrays.asList(allMappingsWithRequest));
+            
+            return this;
+        }
+        
+        public void verify(ResourceResolver resolver, HttpServletRequest request) {
+            checkConfigured();
+            
+            Resource res = resolver.getResource(path);
+            if ( exists ) {
+                assertThat("Resource was null but should exist", res, notNullValue());
+                assertThat("Resource is non-existing but should exist", ResourceUtil.isNonExistingResource(res), is(false));
+            } else {
+                assertThat("Resource is neither null nor non-existing", res == null || ResourceUtil.isNonExistingResource(res), is(true));
+            }
+
+            // downcast to ensure we're testing the right class
+            ResourceMapperImpl mapper = (ResourceMapperImpl) resolver.adaptTo(ResourceMapper.class);
+            
+            assertThat("Single mapping without request", mapper.getMapping(path), is(singleMapping));
+            assertThat("Single mapping with request", mapper.getMapping(path, request), is(singleMappingWithRequest));
+            assertThat("All mappings without request", mapper.getAllMappings(path), is(allMappings));
+            assertThat("All mappings with request", mapper.getAllMappings(path, request), is(allMappingsWithRequest));
+        }
+
+        private void checkConfigured() {
+            if ( singleMapping == null )
+                throw new IllegalStateException("singleMapping is null");
+            if ( singleMappingWithRequest == null )
+                throw new IllegalStateException("singleMappingWithRequest is null");
+            if ( allMappings == null )
+                throw new IllegalStateException("allMappings is null");
+            if ( allMappingsWithRequest == null )
+                throw new IllegalStateException("allMappingsWithRequest is null");
+        }
+    }
+}


[sling-org-apache-sling-resourceresolver] 01/03: SLING-7792 - Resource Resolver should return more than one resolved path if available

Posted by ro...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

rombert pushed a commit to branch feature/SLING-7792
in repository https://gitbox.apache.org/repos/asf/sling-org-apache-sling-resourceresolver.git

commit c64f246765bc1aef4aa536bdd3ad6a723858c920
Author: Robert Munteanu <ro...@apache.org>
AuthorDate: Tue Aug 14 16:05:32 2018 +0200

    SLING-7792 - Resource Resolver should return more than one resolved path if available
    
    Use latest SNAPSHOT for maven-sling-plugin to work around SLING-7828
---
 pom.xml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pom.xml b/pom.xml
index 87f5411..d0280c6 100644
--- a/pom.xml
+++ b/pom.xml
@@ -51,6 +51,7 @@
             <plugin>
                 <groupId>org.apache.sling</groupId>
                 <artifactId>maven-sling-plugin</artifactId>
+                <version>2.3.7-SNAPSHOT</version>
                 <executions>
                     <execution>
                         <id>generate-adapter-metadata</id>


[sling-org-apache-sling-resourceresolver] 02/03: SLING-7792 - Resource Resolver should return more than one resolved path if available

Posted by ro...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

rombert pushed a commit to branch feature/SLING-7792
in repository https://gitbox.apache.org/repos/asf/sling-org-apache-sling-resourceresolver.git

commit 07955b34a904d3d474e92e33258e435451063e59
Author: Robert Munteanu <ro...@apache.org>
AuthorDate: Fri Aug 17 10:55:03 2018 +0200

    SLING-7792 - Resource Resolver should return more than one resolved path if available
    
    Use latest version of the API snapshot
---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index d0280c6..1af4ca9 100644
--- a/pom.xml
+++ b/pom.xml
@@ -98,7 +98,7 @@
         <dependency>
             <groupId>org.apache.sling</groupId>
             <artifactId>org.apache.sling.api</artifactId>
-            <version>2.18.2</version>
+            <version>2.18.3-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>
         <dependency>