Jetty 12 - Issue #8474 - return null on resolve() if resource doesn't exist

jetty-core/jetty-deploy/src/main/java/org/eclipse/jetty/deploy/providers/ScanningAppProvider.java

@@ -226,7 +226,7 @@ protected void doStart() throws Exception
         List<Path> files = new ArrayList<>();
         for (Resource resource : _monitored)
         {
-            if (resource.exists() && Files.isReadable(resource.getPath()))
+            if (resource != null && Files.isReadable(resource.getPath()))
                 files.add(resource.getPath());
             else
                 LOG.warn("Does not exist: {}", resource);
@@ -339,7 +339,11 @@ public void setDeploymentManager(DeploymentManager deploymentManager)
     public void setMonitoredResources(List<Resource> resources)
     {
         _monitored.clear();
-        _monitored.addAll(resources);
+        for (Resource resource: resources)
+        {
+            if (resource != null)
+                _monitored.addAll(resources);
+        }
     }
 
     public List<Resource> getMonitoredResources()

jetty-core/jetty-keystore/src/main/config/modules/test-keystore.mod

@@ -6,7 +6,7 @@ DO NOT USE IN PRODUCTION!!!
 demo
 ssl
 
-[depend]
+[before]
 ssl
 
 [files]

jetty-core/jetty-server/src/main/java/org/eclipse/jetty/server/handler/ContextHandler.java

@@ -720,7 +720,18 @@ public void setBaseResource(Resource resourceBase)
 
     public void setBaseResource(Path path)
     {
-        setBaseResource(path == null ? null : ResourceFactory.root().newResource(path));
+        if (path == null)
+        {
+            // allow user to unset variable
+            setBaseResource((Resource)null);
+            return;
+        }
+
+        Resource resource = ResourceFactory.root().newResource(path);
+        if (resource == null)
+            throw new IllegalArgumentException("Base Resource does not exist: " + path);
+
+        setBaseResource(resource);
     }
 
     /**

jetty-core/jetty-util/src/main/java/org/eclipse/jetty/util/TypeUtil.java

@@ -695,17 +695,7 @@ public static URI getClassLoaderLocation(Class<?> clazz, ClassLoader loader)
                 if (url != null)
                 {
                     URI uri = url.toURI();
-                    String uriStr = uri.toASCIIString();
-                    if (uriStr.startsWith("jar:file:"))
-                    {
-                        uriStr = uriStr.substring(4);
-                        int idx = uriStr.indexOf("!/");
-                        if (idx > 0)
-                        {
-                            return URI.create(uriStr.substring(0, idx));
-                        }
-                    }
-                    return uri;
+                    return URIUtil.unwrapContainer(uri);
                 }
             }
         }

jetty-core/jetty-util/src/main/java/org/eclipse/jetty/util/resource/MemoryResource.java

@@ -106,6 +106,12 @@ public long length()
         return _bytes.length;
     }
 
+    @Override
+    public Resource resolve(String subUriPath)
+    {
+        return null;
+    }
+
     @Override
     public InputStream newInputStream() throws IOException
     {

jetty-core/jetty-util/src/main/java/org/eclipse/jetty/util/resource/MountedPathResource.java

@@ -16,7 +16,9 @@
 import java.io.IOException;
 import java.net.URI;
 import java.nio.file.FileSystem;
+import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.Paths;
 
 import org.eclipse.jetty.util.URIUtil;
 
@@ -26,6 +28,14 @@
  */
 public class MountedPathResource extends PathResource
 {
+    public static MountedPathResource of(URI uri) throws IOException
+    {
+        Path path = Paths.get(uri.normalize());
+        if (!Files.exists(path))
+            return null;
+        return new MountedPathResource(path, uri);
+    }
+
     private final URI containerUri;
 
     MountedPathResource(URI uri) throws IOException
@@ -34,6 +44,18 @@ public class MountedPathResource extends PathResource
         containerUri = URIUtil.unwrapContainer(getURI());
     }
 
+    MountedPathResource(Path path, URI uri)
+    {
+        super(path, uri, true);
+        containerUri = URIUtil.unwrapContainer(getURI());
+    }
+
+    @Override
+    protected Resource newResource(Path path, URI uri)
+    {
+        return new MountedPathResource(path, uri);
+    }
+
     @Override
     public boolean isContainedIn(Resource r)
     {

jetty-core/jetty-util/src/main/java/org/eclipse/jetty/util/resource/PathResource.java

@@ -47,6 +47,14 @@ public class PathResource extends Resource
         .with("jrt")
         .build();
 
+    public static PathResource of(URI uri) throws IOException
+    {
+        Path path = Paths.get(uri.normalize());
+        if (!Files.exists(path))
+            return null;
+        return new PathResource(path, uri, false);
+    }
+
     private final Path path;
     private final URI uri;
     private boolean targetResolved = false;
@@ -247,9 +255,53 @@ public int hashCode()
         return Objects.hashCode(path);
     }
 
+    @Override
+    public Resource resolve(String subUriPath)
+    {
+        // Check that the path is within the root,
+        // but use the original path to create the
+        // resource, to preserve aliasing.
+        // TODO do a URI safe encoding?
+        if (URIUtil.isNotNormalWithinSelf(subUriPath))
+            throw new IllegalArgumentException(subUriPath);
+
+        if (URIUtil.SLASH.equals(subUriPath))
+            return this;
+
+        // Sub-paths are always resolved under the given URI,
+        // we compensate for input sub-paths like "/subdir"
+        // where default resolve behavior would be to treat
+        // that like an absolute path.
+        while (subUriPath.startsWith(URIUtil.SLASH))
+        {
+            // TODO XXX this appears entirely unnecessary and inefficient.  We already have utilities
+            //      to handle appending path strings with/without slashes.
+            subUriPath = subUriPath.substring(1);
+        }
+
+        URI uri = getURI();
+        URI resolvedUri = URIUtil.addPath(uri, subUriPath);
+        Path path = Paths.get(resolvedUri.normalize());
+        if (Files.exists(path))
+            return newResource(path, resolvedUri);
+
+        return null;
+    }
+
+    /**
+     * Internal override for creating a new PathResource.
+     * Used by MountedPathResource (eg)
+     */
+    protected Resource newResource(Path path, URI uri)
+    {
+        return new PathResource(path, uri, true);
+    }
+
     @Override
     public boolean isContainedIn(Resource r)
     {
+        if (r == null)
+            return false;
         return r.getClass() == PathResource.class && path.startsWith(r.getPath());
     }
 

jetty-core/jetty-util/src/main/java/org/eclipse/jetty/util/resource/Resource.java

@@ -115,9 +115,9 @@ static Resource create(URI uri)
 
             // If the scheme is allowed by PathResource, we can build a non-mounted PathResource.
             if (PathResource.ALLOWED_SCHEMES.contains(uri.getScheme()))
-                return new PathResource(uri);
+                return PathResource.of(uri);
 
-            return new MountedPathResource(uri);
+            return MountedPathResource.of(uri);
         }
         catch (URISyntaxException | ProviderNotFoundException | IOException ex)
         {
@@ -292,33 +292,7 @@ public List<Resource> list()
      * @return a Resource representing the subUriPath
      * @throws IllegalArgumentException if subUriPath is invalid
      */
-    public Resource resolve(String subUriPath)
-    {
-        // Check that the path is within the root,
-        // but use the original path to create the
-        // resource, to preserve aliasing.
-        // TODO do a URI safe encoding?
-        if (URIUtil.isNotNormalWithinSelf(subUriPath))
-            throw new IllegalArgumentException(subUriPath);
-
-        if (URIUtil.SLASH.equals(subUriPath))
-            return this;
-
-        // Sub-paths are always resolved under the given URI,
-        // we compensate for input sub-paths like "/subdir"
-        // where default resolve behavior would be to treat
-        // that like an absolute path.
-        while (subUriPath.startsWith(URIUtil.SLASH))
-        {
-            // TODO XXX this appears entirely unnecessary and inefficient.  We already have utilities
-            //      to handle appending path strings with/without slashes.
-            subUriPath = subUriPath.substring(1);
-        }
-
-        URI uri = getURI();
-        URI resolvedUri = URIUtil.addPath(uri, subUriPath);
-        return create(resolvedUri);
-    }
+    public abstract Resource resolve(String subUriPath);
 
     /**
      * @return true if this Resource is an alias to another real Resource

jetty-core/jetty-util/src/main/java/org/eclipse/jetty/util/resource/ResourceCollection.java

@@ -126,8 +126,8 @@ public Resource resolve(String subUriPath)
         for (Resource res : _resources)
         {
             addedResource = res.resolve(subUriPath);
-            if (!addedResource.exists())
-                continue;
+            if (addedResource == null)
+                continue; // skip, doesn't exist
             if (!addedResource.isDirectory())
                 return addedResource; // Return simple (non-directory) Resource
             if (resources == null)

jetty-core/jetty-util/src/main/java/org/eclipse/jetty/util/resource/ResourceFactory.java

@@ -22,6 +22,7 @@
 
 import org.eclipse.jetty.util.FileID;
 import org.eclipse.jetty.util.Loader;
+import org.eclipse.jetty.util.StringUtil;
 import org.eclipse.jetty.util.URIUtil;
 import org.eclipse.jetty.util.component.Container;
 import org.eclipse.jetty.util.component.Dumpable;
@@ -49,6 +50,9 @@ public interface ResourceFactory
      */
     default Resource newSystemResource(String resource)
     {
+        if (StringUtil.isBlank(resource))
+            return null;
+
         URL url = null;
         // Try to format as a URL?
         ClassLoader loader = Thread.currentThread().getContextClassLoader();
@@ -110,6 +114,9 @@ default Resource newSystemResource(String resource)
      */
     default Resource newClassPathResource(String resource)
     {
+        if (StringUtil.isBlank(resource))
+            return null;
+
         URL url = ResourceFactory.class.getResource(resource);
 
         if (url == null)
@@ -135,6 +142,9 @@ default Resource newClassPathResource(String resource)
      */
     default Resource newMemoryResource(URL url)
     {
+        if (url == null)
+            return null;
+
         return new MemoryResource(url);
     }
 
@@ -146,6 +156,9 @@ default Resource newMemoryResource(URL url)
      */
     default Resource newResource(String resource)
     {
+        if (StringUtil.isBlank(resource))
+            return null;
+
         return newResource(URIUtil.toURI(resource));
     }
 
@@ -157,6 +170,9 @@ default Resource newResource(String resource)
      */
     default Resource newResource(Path path)
     {
+        if (path == null)
+            return null;
+
         return newResource(path.toUri());
     }
 
@@ -168,11 +184,17 @@ default Resource newResource(Path path)
      */
     default ResourceCollection newResource(List<URI> uris)
     {
+        if ((uris == null) || (uris.isEmpty()))
+            return null;
+
         return Resource.combine(uris.stream().map(this::newResource).toList());
     }
 
     default Resource newResource(URL url)
     {
+        if (url == null)
+            return null;
+
         try
         {
             return newResource(url.toURI());

jetty-core/jetty-util/src/main/java/org/eclipse/jetty/util/ssl/SslContextFactory.java

@@ -632,7 +632,20 @@ public String getKeyStorePath()
      */
     public void setKeyStorePath(String keyStorePath)
     {
-        _keyStoreResource = ResourceFactory.of(this).newResource(keyStorePath);
+        if (StringUtil.isBlank(keyStorePath))
+        {
+            // allow user to unset variable
+            _keyStoreResource = null;
+            return;
+        }
+
+        Resource res = ResourceFactory.of(this).newResource(keyStorePath);
+        if (res == null)
+        {
+            _keyStoreResource = null;
+            throw new IllegalArgumentException("KeyStore Path does not exist: " + keyStorePath);
+        }
+        _keyStoreResource = res;
     }
 
     /**
@@ -703,7 +716,20 @@ public String getTrustStorePath()
      */
     public void setTrustStorePath(String trustStorePath)
     {
-        _trustStoreResource = StringUtil.isEmpty(trustStorePath) ? null : ResourceFactory.of(this).newResource(trustStorePath);
+        if (StringUtil.isBlank(trustStorePath))
+        {
+            // allow user to unset variable
+            _trustStoreResource = null;
+            return;
+        }
+
+        Resource res = ResourceFactory.of(this).newResource(trustStorePath);
+        if (res == null)
+        {
+            _trustStoreResource = null;
+            throw new IllegalArgumentException("TrustStore Path does not exist: " + trustStorePath);
+        }
+        _trustStoreResource = res;
     }
 
     /**