Merge branch 'jetty-9.2.x' into jetty-9.3.x

Conflicts:
	jetty-http/src/main/java/org/eclipse/jetty/http/HttpGenerator.java
	jetty-http/src/main/java/org/eclipse/jetty/http/PathMap.java
	jetty-maven-plugin/src/main/java/org/eclipse/jetty/maven/plugin/AbstractJettyMojo.java
	jetty-maven-plugin/src/main/java/org/eclipse/jetty/maven/plugin/WarPluginInfo.java
	jetty-rhttp/jetty-rhttp-gateway/src/main/java/org/eclipse/jetty/rhttp/gateway/Main.java
	jetty-security/src/main/java/org/eclipse/jetty/security/PropertyUserStore.java
	jetty-servlets/src/main/java/org/eclipse/jetty/servlets/CrossOriginFilter.java
	jetty-servlets/src/main/java/org/eclipse/jetty/servlets/GzipFilter.java
	jetty-servlets/src/main/java/org/eclipse/jetty/servlets/gzip/CompressedResponseWrapper.java
	jetty-servlets/src/main/java/org/eclipse/jetty/servlets/gzip/GzipHandler.java
	jetty-util/src/main/java/org/eclipse/jetty/util/IncludeExclude.java
	jetty-util/src/main/java/org/eclipse/jetty/util/RegexSet.java
	jetty-util/src/test/java/org/eclipse/jetty/util/IncludeExcludeTest.java
	jetty-util/src/test/java/org/eclipse/jetty/util/ssl/SslContextFactoryTest.java
This commit is contained in:
Joakim Erdfelt 2015-12-16 12:56:13 -07:00
commit 343aa066ae
26 changed files with 2882 additions and 42 deletions

View File

@ -29,7 +29,8 @@ import java.util.StringTokenizer;
import java.util.function.BiFunction;
import org.eclipse.jetty.util.ArrayTernaryTrie;
import org.eclipse.jetty.util.RegexSet;
import org.eclipse.jetty.util.IncludeExclude;
import org.eclipse.jetty.util.Predicate;
import org.eclipse.jetty.util.Trie;
import org.eclipse.jetty.util.URIUtil;
@ -592,9 +593,8 @@ public class PathMap<O> extends HashMap<String,O>
}
}
public static class PathSet extends AbstractSet<String>
public static class PathSet extends AbstractSet<String> implements Predicate<String>
{
public static final BiFunction<PathSet,String,Boolean> MATCHER=(s,e)->{return s.containsMatch(e);};
private final PathMap<Boolean> _map = new PathMap<>();
@Override
@ -627,12 +627,15 @@ public class PathMap<O> extends HashMap<String,O>
return _map.containsKey(o);
}
@Override
public boolean test(String s)
{
return _map.containsMatch(s);
}
public boolean containsMatch(String s)
{
return _map.containsMatch(s);
}
}
}

View File

@ -0,0 +1,101 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
import org.eclipse.jetty.util.annotation.ManagedAttribute;
import org.eclipse.jetty.util.annotation.ManagedObject;
@ManagedObject("Mapped Resource")
public class MappedResource<E> implements Comparable<MappedResource<E>>
{
private final PathSpec pathSpec;
private final E resource;
public MappedResource(PathSpec pathSpec, E resource)
{
this.pathSpec = pathSpec;
this.resource = resource;
}
/**
* Comparison is based solely on the pathSpec
*/
@Override
public int compareTo(MappedResource<E> other)
{
return this.pathSpec.compareTo(other.pathSpec);
}
@Override
public boolean equals(Object obj)
{
if (this == obj)
{
return true;
}
if (obj == null)
{
return false;
}
if (getClass() != obj.getClass())
{
return false;
}
MappedResource<?> other = (MappedResource<?>)obj;
if (pathSpec == null)
{
if (other.pathSpec != null)
{
return false;
}
}
else if (!pathSpec.equals(other.pathSpec))
{
return false;
}
return true;
}
@ManagedAttribute(value = "path spec", readonly = true)
public PathSpec getPathSpec()
{
return pathSpec;
}
@ManagedAttribute(value = "resource", readonly = true)
public E getResource()
{
return resource;
}
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = (prime * result) + ((pathSpec == null) ? 0 : pathSpec.hashCode());
return result;
}
@Override
public String toString()
{
return String.format("MappedResource[pathSpec=%s,resource=%s]",pathSpec,resource);
}
}

View File

@ -0,0 +1,159 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.eclipse.jetty.util.annotation.ManagedAttribute;
import org.eclipse.jetty.util.annotation.ManagedObject;
import org.eclipse.jetty.util.component.ContainerLifeCycle;
import org.eclipse.jetty.util.component.Dumpable;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
/**
* Path Mappings of PathSpec to Resource.
* <p>
* Sorted into search order upon entry into the Set
*
* @param <E> the type of mapping endpoint
*/
@ManagedObject("Path Mappings")
public class PathMappings<E> implements Iterable<MappedResource<E>>, Dumpable
{
private static final Logger LOG = Log.getLogger(PathMappings.class);
private List<MappedResource<E>> mappings = new ArrayList<MappedResource<E>>();
private MappedResource<E> defaultResource = null;
private MappedResource<E> rootResource = null;
@Override
public String dump()
{
return ContainerLifeCycle.dump(this);
}
@Override
public void dump(Appendable out, String indent) throws IOException
{
ContainerLifeCycle.dump(out,indent,mappings);
}
@ManagedAttribute(value = "mappings", readonly = true)
public List<MappedResource<E>> getMappings()
{
return mappings;
}
public void reset()
{
mappings.clear();
}
/**
* Return a list of MappedResource matches for the specified path.
*
* @param path the path to return matches on
* @return the list of mapped resource the path matches on
*/
public List<MappedResource<E>> getMatches(String path)
{
boolean matchRoot = "/".equals(path);
List<MappedResource<E>> ret = new ArrayList<>();
int len = mappings.size();
for (int i = 0; i < len; i++)
{
MappedResource<E> mr = mappings.get(i);
switch (mr.getPathSpec().group)
{
case ROOT:
if (matchRoot)
ret.add(mr);
break;
case DEFAULT:
if (matchRoot || mr.getPathSpec().matches(path))
ret.add(mr);
break;
default:
if (mr.getPathSpec().matches(path))
ret.add(mr);
break;
}
}
return ret;
}
public MappedResource<E> getMatch(String path)
{
if (path.equals("/") && rootResource != null)
{
return rootResource;
}
int len = mappings.size();
for (int i = 0; i < len; i++)
{
MappedResource<E> mr = mappings.get(i);
if (mr.getPathSpec().matches(path))
{
return mr;
}
}
return defaultResource;
}
@Override
public Iterator<MappedResource<E>> iterator()
{
return mappings.iterator();
}
@SuppressWarnings("incomplete-switch")
public void put(PathSpec pathSpec, E resource)
{
MappedResource<E> entry = new MappedResource<>(pathSpec,resource);
switch (pathSpec.group)
{
case DEFAULT:
defaultResource = entry;
break;
case ROOT:
rootResource = entry;
break;
}
// TODO: add warning when replacing an existing pathspec?
mappings.add(entry);
if (LOG.isDebugEnabled())
LOG.debug("Added {} to {}",entry,this);
Collections.sort(mappings);
}
@Override
public String toString()
{
return String.format("%s[size=%d]",this.getClass().getSimpleName(),mappings.size());
}
}

View File

@ -0,0 +1,167 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
/**
* The base PathSpec, what all other path specs are based on
*/
public abstract class PathSpec implements Comparable<PathSpec>
{
protected String pathSpec;
protected PathSpecGroup group;
protected int pathDepth;
protected int specLength;
@Override
public int compareTo(PathSpec other)
{
// Grouping (increasing)
int diff = this.group.ordinal() - other.group.ordinal();
if (diff != 0)
{
return diff;
}
// Spec Length (decreasing)
diff = other.specLength - this.specLength;
if (diff != 0)
{
return diff;
}
// Path Spec Name (alphabetical)
return this.pathSpec.compareTo(other.pathSpec);
}
@Override
public boolean equals(Object obj)
{
if (this == obj)
{
return true;
}
if (obj == null)
{
return false;
}
if (getClass() != obj.getClass())
{
return false;
}
PathSpec other = (PathSpec)obj;
if (pathSpec == null)
{
if (other.pathSpec != null)
{
return false;
}
}
else if (!pathSpec.equals(other.pathSpec))
{
return false;
}
return true;
}
public PathSpecGroup getGroup()
{
return group;
}
/**
* Get the number of path elements that this path spec declares.
* <p>
* This is used to determine longest match logic.
*
* @return the depth of the path segments that this spec declares
*/
public int getPathDepth()
{
return pathDepth;
}
/**
* Return the portion of the path that is after the path spec.
*
* @param path
* the path to match against
* @return the path info portion of the string
*/
public abstract String getPathInfo(String path);
/**
* Return the portion of the path that matches a path spec.
*
* @param path
* the path to match against
* @return the match, or null if no match at all
*/
public abstract String getPathMatch(String path);
/**
* The as-provided path spec.
*
* @return the as-provided path spec
*/
public String getDeclaration()
{
return pathSpec;
}
/**
* Get the relative path.
*
* @param base
* the base the path is relative to
* @param path
* the additional path
* @return the base plus path with pathSpec portion removed
*/
public abstract String getRelativePath(String base, String path);
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = (prime * result) + ((pathSpec == null)?0:pathSpec.hashCode());
return result;
}
/**
* Test to see if the provided path matches this path spec
*
* @param path
* the path to test
* @return true if the path matches this path spec, false otherwise
*/
public abstract boolean matches(String path);
@Override
public String toString()
{
StringBuilder str = new StringBuilder();
str.append(this.getClass().getSimpleName()).append("[\"");
str.append(pathSpec);
str.append("\",pathDepth=").append(pathDepth);
str.append(",group=").append(group);
str.append("]");
return str.toString();
}
}

View File

@ -0,0 +1,101 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
/**
* Types of path spec groups.
* <p>
* This is used to facilitate proper pathspec search order.
* <p>
* Search Order:
* <ol>
* <li>{@link PathSpecGroup#ordinal()} [increasing]</li>
* <li>{@link PathSpec#specLength} [decreasing]</li>
* <li>{@link PathSpec#pathSpec} [natural sort order]</li>
* </ol>
*/
public enum PathSpecGroup
{
// NOTE: Order of enums determines order of Groups.
/**
* For exactly defined path specs, no glob.
*/
EXACT,
/**
* For path specs that have a hardcoded prefix and suffix with wildcard glob in the middle.
*
* <pre>
* "^/downloads/[^/]*.zip$" - regex spec
* "/a/{var}/c" - uri-template spec
* </pre>
*
* Note: there is no known servlet spec variant of this kind of path spec
*/
MIDDLE_GLOB,
/**
* For path specs that have a hardcoded prefix and a trailing wildcard glob.
* <p>
*
* <pre>
* "/downloads/*" - servlet spec
* "/api/*" - servlet spec
* "^/rest/.*$" - regex spec
* "/bookings/{guest-id}" - uri-template spec
* "/rewards/{vip-level}" - uri-template spec
* </pre>
*/
PREFIX_GLOB,
/**
* For path specs that have a wildcard glob with a hardcoded suffix
*
* <pre>
* "*.do" - servlet spec
* "*.css" - servlet spec
* "^.*\.zip$" - regex spec
* </pre>
*
* Note: there is no known uri-template spec variant of this kind of path spec
*/
SUFFIX_GLOB,
/**
* The root spec for accessing the Root behavior.
*
* <pre>
* "" - servlet spec (Root Servlet)
* null - servlet spec (Root Servlet)
* </pre>
*
* Note: there is no known uri-template spec variant of this kind of path spec
*/
ROOT,
/**
* The default spec for accessing the Default path behavior.
*
* <pre>
* "/" - servlet spec (Default Servlet)
* "/" - uri-template spec (Root Context)
* "^/$" - regex spec (Root Context)
* </pre>
*
* Per Servlet Spec, pathInfo is always null for these specs.
* If nothing above matches, then default will match.
*/
DEFAULT,
}

View File

@ -0,0 +1,223 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import org.eclipse.jetty.util.Predicate;
/**
* A Set of PathSpec strings.
* <p>
* Used by {@link org.eclipse.jetty.util.IncludeExclude} logic
*/
public class PathSpecSet implements Set<String>, Predicate<String>
{
private final Set<PathSpec> specs = new TreeSet<>();
@Override
public boolean test(String s)
{
for (PathSpec spec : specs)
{
if (spec.matches(s))
{
return true;
}
}
return false;
}
@Override
public boolean isEmpty()
{
return specs.isEmpty();
}
@Override
public Iterator<String> iterator()
{
return new Iterator<String>()
{
private Iterator<PathSpec> iter = specs.iterator();
@Override
public boolean hasNext()
{
return iter.hasNext();
}
@Override
public String next()
{
PathSpec spec = iter.next();
if (spec == null)
{
return null;
}
return spec.getDeclaration();
}
@Override
public void remove()
{
throw new UnsupportedOperationException("Remove not supported by this Iterator");
}
};
}
@Override
public int size()
{
return specs.size();
}
@Override
public boolean contains(Object o)
{
if (o instanceof PathSpec)
{
return specs.contains(o);
}
if (o instanceof String)
{
return specs.contains(toPathSpec((String)o));
}
return false;
}
private PathSpec asPathSpec(Object o)
{
if (o == null)
{
return null;
}
if (o instanceof PathSpec)
{
return (PathSpec)o;
}
if (o instanceof String)
{
return toPathSpec((String)o);
}
return toPathSpec(o.toString());
}
private PathSpec toPathSpec(String rawSpec)
{
if ((rawSpec == null) || (rawSpec.length() < 1))
{
throw new RuntimeException("Path Spec String must start with '^', '/', or '*.': got [" + rawSpec + "]");
}
if (rawSpec.charAt(0) == '^')
{
return new RegexPathSpec(rawSpec);
}
else
{
return new ServletPathSpec(rawSpec);
}
}
@Override
public Object[] toArray()
{
return toArray(new String[specs.size()]);
}
@Override
public <T> T[] toArray(T[] a)
{
int i = 0;
for (PathSpec spec : specs)
{
a[i++] = (T)spec.getDeclaration();
}
return a;
}
@Override
public boolean add(String e)
{
return specs.add(toPathSpec(e));
}
@Override
public boolean remove(Object o)
{
return specs.remove(asPathSpec(o));
}
@Override
public boolean containsAll(Collection<?> coll)
{
for (Object o : coll)
{
if (!specs.contains(asPathSpec(o)))
return false;
}
return true;
}
@Override
public boolean addAll(Collection<? extends String> coll)
{
boolean ret = false;
for (String s : coll)
{
ret |= add(s);
}
return ret;
}
@Override
public boolean retainAll(Collection<?> coll)
{
List<PathSpec> collSpecs = new ArrayList<>();
for (Object o : coll)
{
collSpecs.add(asPathSpec(o));
}
return specs.retainAll(collSpecs);
}
@Override
public boolean removeAll(Collection<?> coll)
{
List<PathSpec> collSpecs = new ArrayList<>();
for (Object o : coll)
{
collSpecs.add(asPathSpec(o));
}
return specs.removeAll(collSpecs);
}
@Override
public void clear()
{
specs.clear();
}
}

View File

@ -0,0 +1,176 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexPathSpec extends PathSpec
{
protected Pattern pattern;
protected RegexPathSpec()
{
super();
}
public RegexPathSpec(String regex)
{
super.pathSpec = regex;
boolean inGrouping = false;
this.pathDepth = 0;
this.specLength = pathSpec.length();
// build up a simple signature we can use to identify the grouping
StringBuilder signature = new StringBuilder();
for (char c : pathSpec.toCharArray())
{
switch (c)
{
case '[':
inGrouping = true;
break;
case ']':
inGrouping = false;
signature.append('g'); // glob
break;
case '*':
signature.append('g'); // glob
break;
case '/':
if (!inGrouping)
{
this.pathDepth++;
}
break;
default:
if (!inGrouping)
{
if (Character.isLetterOrDigit(c))
{
signature.append('l'); // literal (exact)
}
}
break;
}
}
this.pattern = Pattern.compile(pathSpec);
// Figure out the grouping based on the signature
String sig = signature.toString();
if (Pattern.matches("^l*$",sig))
{
this.group = PathSpecGroup.EXACT;
}
else if (Pattern.matches("^l*g+",sig))
{
this.group = PathSpecGroup.PREFIX_GLOB;
}
else if (Pattern.matches("^g+l+$",sig))
{
this.group = PathSpecGroup.SUFFIX_GLOB;
}
else
{
this.group = PathSpecGroup.MIDDLE_GLOB;
}
}
public Matcher getMatcher(String path)
{
return this.pattern.matcher(path);
}
@Override
public String getPathInfo(String path)
{
// Path Info only valid for PREFIX_GLOB types
if (group == PathSpecGroup.PREFIX_GLOB)
{
Matcher matcher = getMatcher(path);
if (matcher.matches())
{
if (matcher.groupCount() >= 1)
{
String pathInfo = matcher.group(1);
if ("".equals(pathInfo))
{
return "/";
}
else
{
return pathInfo;
}
}
}
}
return null;
}
@Override
public String getPathMatch(String path)
{
Matcher matcher = getMatcher(path);
if (matcher.matches())
{
if (matcher.groupCount() >= 1)
{
int idx = matcher.start(1);
if (idx > 0)
{
if (path.charAt(idx - 1) == '/')
{
idx--;
}
return path.substring(0,idx);
}
}
return path;
}
return null;
}
public Pattern getPattern()
{
return this.pattern;
}
@Override
public String getRelativePath(String base, String path)
{
// TODO Auto-generated method stub
return null;
}
@Override
public boolean matches(final String path)
{
int idx = path.indexOf('?');
if (idx >= 0)
{
// match only non-query part
return getMatcher(path.substring(0,idx)).matches();
}
else
{
// match entire path
return getMatcher(path).matches();
}
}
}

View File

@ -0,0 +1,261 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
import org.eclipse.jetty.util.URIUtil;
public class ServletPathSpec extends PathSpec
{
public ServletPathSpec(String servletPathSpec)
{
super();
assertValidServletPathSpec(servletPathSpec);
// The Root Path Spec
if ((servletPathSpec == null) || (servletPathSpec.length() == 0))
{
super.pathSpec = "";
super.pathDepth = -1; // force this to be at the end of the sort order
this.specLength = 1;
this.group = PathSpecGroup.ROOT;
return;
}
// The Default Path Spec
if("/".equals(servletPathSpec))
{
super.pathSpec = "/";
super.pathDepth = -1; // force this to be at the end of the sort order
this.specLength = 1;
this.group = PathSpecGroup.DEFAULT;
return;
}
this.specLength = servletPathSpec.length();
super.pathDepth = 0;
char lastChar = servletPathSpec.charAt(specLength - 1);
// prefix based
if ((servletPathSpec.charAt(0) == '/') && (specLength > 1) && (lastChar == '*'))
{
this.group = PathSpecGroup.PREFIX_GLOB;
}
// suffix based
else if (servletPathSpec.charAt(0) == '*')
{
this.group = PathSpecGroup.SUFFIX_GLOB;
}
else
{
this.group = PathSpecGroup.EXACT;
}
for (int i = 0; i < specLength; i++)
{
int cp = servletPathSpec.codePointAt(i);
if (cp < 128)
{
char c = (char)cp;
switch (c)
{
case '/':
super.pathDepth++;
break;
}
}
}
super.pathSpec = servletPathSpec;
}
private void assertValidServletPathSpec(String servletPathSpec)
{
if ((servletPathSpec == null) || servletPathSpec.equals(""))
{
return; // empty path spec
}
int len = servletPathSpec.length();
// path spec must either start with '/' or '*.'
if (servletPathSpec.charAt(0) == '/')
{
// Prefix Based
if (len == 1)
{
return; // simple '/' path spec
}
int idx = servletPathSpec.indexOf('*');
if (idx < 0)
{
return; // no hit on glob '*'
}
// only allowed to have '*' at the end of the path spec
if (idx != (len - 1))
{
throw new IllegalArgumentException("Servlet Spec 12.2 violation: glob '*' can only exist at end of prefix based matches: bad spec \""+ servletPathSpec +"\"");
}
}
else if (servletPathSpec.startsWith("*."))
{
// Suffix Based
int idx = servletPathSpec.indexOf('/');
// cannot have path separator
if (idx >= 0)
{
throw new IllegalArgumentException("Servlet Spec 12.2 violation: suffix based path spec cannot have path separators: bad spec \""+ servletPathSpec +"\"");
}
idx = servletPathSpec.indexOf('*',2);
// only allowed to have 1 glob '*', at the start of the path spec
if (idx >= 1)
{
throw new IllegalArgumentException("Servlet Spec 12.2 violation: suffix based path spec cannot have multiple glob '*': bad spec \""+ servletPathSpec +"\"");
}
}
else
{
throw new IllegalArgumentException("Servlet Spec 12.2 violation: path spec must start with \"/\" or \"*.\": bad spec \""+ servletPathSpec +"\"");
}
}
@Override
public String getPathInfo(String path)
{
// Path Info only valid for PREFIX_GLOB types
if (group == PathSpecGroup.PREFIX_GLOB)
{
if (path.length() == (specLength - 2))
{
return null;
}
return path.substring(specLength - 2);
}
return null;
}
@Override
public String getPathMatch(String path)
{
switch (group)
{
case EXACT:
if (pathSpec.equals(path))
{
return path;
}
else
{
return null;
}
case PREFIX_GLOB:
if (isWildcardMatch(path))
{
return path.substring(0,specLength - 2);
}
else
{
return null;
}
case SUFFIX_GLOB:
if (path.regionMatches(path.length() - (specLength - 1),pathSpec,1,specLength - 1))
{
return path;
}
else
{
return null;
}
case DEFAULT:
return path;
default:
return null;
}
}
@Override
public String getRelativePath(String base, String path)
{
String info = getPathInfo(path);
if (info == null)
{
info = path;
}
if (info.startsWith("./"))
{
info = info.substring(2);
}
if (base.endsWith(URIUtil.SLASH))
{
if (info.startsWith(URIUtil.SLASH))
{
path = base + info.substring(1);
}
else
{
path = base + info;
}
}
else if (info.startsWith(URIUtil.SLASH))
{
path = base + info;
}
else
{
path = base + URIUtil.SLASH + info;
}
return path;
}
private boolean isWildcardMatch(String path)
{
// For a spec of "/foo/*" match "/foo" , "/foo/..." but not "/foobar"
int cpl = specLength - 2;
if ((group == PathSpecGroup.PREFIX_GLOB) && (path.regionMatches(0,pathSpec,0,cpl)))
{
if ((path.length() == cpl) || ('/' == path.charAt(cpl)))
{
return true;
}
}
return false;
}
@Override
public boolean matches(String path)
{
switch (group)
{
case EXACT:
return pathSpec.equals(path);
case PREFIX_GLOB:
return isWildcardMatch(path);
case SUFFIX_GLOB:
return path.regionMatches((path.length() - specLength) + 1,pathSpec,1,specLength - 1);
case ROOT:
// Only "/" matches
return ("/".equals(path));
case DEFAULT:
// If we reached this point, then everything matches
return true;
default:
return false;
}
}
}

View File

@ -0,0 +1,341 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.eclipse.jetty.util.TypeUtil;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
/**
* PathSpec for URI Template based declarations
*
* @see <a href="https://tools.ietf.org/html/rfc6570">URI Templates (Level 1)</a>
*/
public class UriTemplatePathSpec extends RegexPathSpec
{
private static final Logger LOG = Log.getLogger(UriTemplatePathSpec.class);
private static final Pattern VARIABLE_PATTERN = Pattern.compile("\\{(.*)\\}");
/** Reserved Symbols in URI Template variable */
private static final String VARIABLE_RESERVED = ":/?#[]@" + // gen-delims
"!$&'()*+,;="; // sub-delims
/** Allowed Symbols in a URI Template variable */
private static final String VARIABLE_SYMBOLS="-._";
private static final Set<String> FORBIDDEN_SEGMENTS;
static
{
FORBIDDEN_SEGMENTS = new HashSet<>();
FORBIDDEN_SEGMENTS.add("/./");
FORBIDDEN_SEGMENTS.add("/../");
FORBIDDEN_SEGMENTS.add("//");
}
private String variables[];
public UriTemplatePathSpec(String rawSpec)
{
super();
Objects.requireNonNull(rawSpec,"Path Param Spec cannot be null");
if ("".equals(rawSpec) || "/".equals(rawSpec))
{
super.pathSpec = "/";
super.pattern = Pattern.compile("^/$");
super.pathDepth = 1;
this.specLength = 1;
this.variables = new String[0];
this.group = PathSpecGroup.EXACT;
return;
}
if (rawSpec.charAt(0) != '/')
{
// path specs must start with '/'
StringBuilder err = new StringBuilder();
err.append("Syntax Error: path spec \"");
err.append(rawSpec);
err.append("\" must start with '/'");
throw new IllegalArgumentException(err.toString());
}
for (String forbidden : FORBIDDEN_SEGMENTS)
{
if (rawSpec.contains(forbidden))
{
StringBuilder err = new StringBuilder();
err.append("Syntax Error: segment ");
err.append(forbidden);
err.append(" is forbidden in path spec: ");
err.append(rawSpec);
throw new IllegalArgumentException(err.toString());
}
}
this.pathSpec = rawSpec;
StringBuilder regex = new StringBuilder();
regex.append('^');
List<String> varNames = new ArrayList<>();
// split up into path segments (ignoring the first slash that will always be empty)
String segments[] = rawSpec.substring(1).split("/");
char segmentSignature[] = new char[segments.length];
this.pathDepth = segments.length;
for (int i = 0; i < segments.length; i++)
{
String segment = segments[i];
Matcher mat = VARIABLE_PATTERN.matcher(segment);
if (mat.matches())
{
// entire path segment is a variable.
String variable = mat.group(1);
if (varNames.contains(variable))
{
// duplicate variable names
StringBuilder err = new StringBuilder();
err.append("Syntax Error: variable ");
err.append(variable);
err.append(" is duplicated in path spec: ");
err.append(rawSpec);
throw new IllegalArgumentException(err.toString());
}
assertIsValidVariableLiteral(variable);
segmentSignature[i] = 'v'; // variable
// valid variable name
varNames.add(variable);
// build regex
regex.append("/([^/]+)");
}
else if (mat.find(0))
{
// variable exists as partial segment
StringBuilder err = new StringBuilder();
err.append("Syntax Error: variable ");
err.append(mat.group());
err.append(" must exist as entire path segment: ");
err.append(rawSpec);
throw new IllegalArgumentException(err.toString());
}
else if ((segment.indexOf('{') >= 0) || (segment.indexOf('}') >= 0))
{
// variable is split with a path separator
StringBuilder err = new StringBuilder();
err.append("Syntax Error: invalid path segment /");
err.append(segment);
err.append("/ variable declaration incomplete: ");
err.append(rawSpec);
throw new IllegalArgumentException(err.toString());
}
else if (segment.indexOf('*') >= 0)
{
// glob segment
StringBuilder err = new StringBuilder();
err.append("Syntax Error: path segment /");
err.append(segment);
err.append("/ contains a wildcard symbol (not supported by this uri-template implementation): ");
err.append(rawSpec);
throw new IllegalArgumentException(err.toString());
}
else
{
// valid path segment
segmentSignature[i] = 'e'; // exact
// build regex
regex.append('/');
// escape regex special characters
for (char c : segment.toCharArray())
{
if ((c == '.') || (c == '[') || (c == ']') || (c == '\\'))
{
regex.append('\\');
}
regex.append(c);
}
}
}
// Handle trailing slash (which is not picked up during split)
if(rawSpec.charAt(rawSpec.length()-1) == '/')
{
regex.append('/');
}
regex.append('$');
this.pattern = Pattern.compile(regex.toString());
int varcount = varNames.size();
this.variables = varNames.toArray(new String[varcount]);
// Convert signature to group
String sig = String.valueOf(segmentSignature);
if (Pattern.matches("^e*$",sig))
{
this.group = PathSpecGroup.EXACT;
}
else if (Pattern.matches("^e*v+",sig))
{
this.group = PathSpecGroup.PREFIX_GLOB;
}
else if (Pattern.matches("^v+e+",sig))
{
this.group = PathSpecGroup.SUFFIX_GLOB;
}
else
{
this.group = PathSpecGroup.MIDDLE_GLOB;
}
}
/**
* Validate variable literal name, per RFC6570, Section 2.1 Literals
* @param variable
* @param pathParamSpec
*/
private void assertIsValidVariableLiteral(String variable)
{
int len = variable.length();
int i = 0;
int codepoint;
boolean valid = (len > 0); // must not be zero length
while (valid && i < len)
{
codepoint = variable.codePointAt(i);
i += Character.charCount(codepoint);
// basic letters, digits, or symbols
if (isValidBasicLiteralCodepoint(codepoint))
{
continue;
}
// The ucschar and iprivate pieces
if (Character.isSupplementaryCodePoint(codepoint))
{
continue;
}
// pct-encoded
if (codepoint == '%')
{
if (i + 2 > len)
{
// invalid percent encoding, missing extra 2 chars
valid = false;
continue;
}
codepoint = TypeUtil.convertHexDigit(variable.codePointAt(i++)) << 4;
codepoint |= TypeUtil.convertHexDigit(variable.codePointAt(i++));
// validate basic literal
if (isValidBasicLiteralCodepoint(codepoint))
{
continue;
}
}
valid = false;
}
if (!valid)
{
// invalid variable name
StringBuilder err = new StringBuilder();
err.append("Syntax Error: variable {");
err.append(variable);
err.append("} an invalid variable name: ");
err.append(pathSpec);
throw new IllegalArgumentException(err.toString());
}
}
private boolean isValidBasicLiteralCodepoint(int codepoint)
{
// basic letters or digits
if((codepoint >= 'a' && codepoint <= 'z') ||
(codepoint >= 'A' && codepoint <= 'Z') ||
(codepoint >= '0' && codepoint <= '9'))
{
return true;
}
// basic allowed symbols
if(VARIABLE_SYMBOLS.indexOf(codepoint) >= 0)
{
return true; // valid simple value
}
// basic reserved symbols
if(VARIABLE_RESERVED.indexOf(codepoint) >= 0)
{
LOG.warn("Detected URI Template reserved symbol [{}] in path spec \"{}\"",(char)codepoint,pathSpec);
return false; // valid simple value
}
return false;
}
public Map<String, String> getPathParams(String path)
{
Matcher matcher = getMatcher(path);
if (matcher.matches())
{
if (group == PathSpecGroup.EXACT)
{
return Collections.emptyMap();
}
Map<String, String> ret = new HashMap<>();
int groupCount = matcher.groupCount();
for (int i = 1; i <= groupCount; i++)
{
ret.put(this.variables[i - 1],matcher.group(i));
}
return ret;
}
return null;
}
public int getVariableCount()
{
return variables.length;
}
public String[] getVariables()
{
return this.variables;
}
}

View File

@ -0,0 +1,281 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
import static org.hamcrest.Matchers.notNullValue;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.junit.Assert;
import org.junit.Test;
public class PathMappingsTest
{
private void assertMatch(PathMappings<String> pathmap, String path, String expectedValue)
{
String msg = String.format(".getMatch(\"%s\")",path);
MappedResource<String> match = pathmap.getMatch(path);
Assert.assertThat(msg,match,notNullValue());
String actualMatch = match.getResource();
Assert.assertEquals(msg,expectedValue,actualMatch);
}
public void dumpMappings(PathMappings<String> p)
{
for (MappedResource<String> res : p)
{
System.out.printf(" %s%n",res);
}
}
/**
* Test the match order rules with a mixed Servlet and regex path specs
* <p>
* <ul>
* <li>Exact match</li>
* <li>Longest prefix match</li>
* <li>Longest suffix match</li>
* </ul>
*/
@Test
public void testMixedMatchOrder()
{
PathMappings<String> p = new PathMappings<>();
p.put(new ServletPathSpec("/"),"default");
p.put(new ServletPathSpec("/animal/bird/*"),"birds");
p.put(new ServletPathSpec("/animal/fish/*"),"fishes");
p.put(new ServletPathSpec("/animal/*"),"animals");
p.put(new RegexPathSpec("^/animal/.*/chat$"),"animalChat");
p.put(new RegexPathSpec("^/animal/.*/cam$"),"animalCam");
p.put(new RegexPathSpec("^/entrance/cam$"),"entranceCam");
// dumpMappings(p);
assertMatch(p,"/animal/bird/eagle","birds");
assertMatch(p,"/animal/fish/bass/sea","fishes");
assertMatch(p,"/animal/peccary/javalina/evolution","animals");
assertMatch(p,"/","default");
assertMatch(p,"/animal/bird/eagle/chat","animalChat");
assertMatch(p,"/animal/bird/penguin/chat","animalChat");
assertMatch(p,"/animal/fish/trout/cam","animalCam");
assertMatch(p,"/entrance/cam","entranceCam");
}
/**
* Test the match order rules imposed by the Servlet API (default vs any)
*/
@Test
public void testServletMatchDefault()
{
PathMappings<String> p = new PathMappings<>();
p.put(new ServletPathSpec("/"),"default");
p.put(new ServletPathSpec("/*"),"any");
assertMatch(p,"/abs/path","any");
assertMatch(p,"/abs/path/xxx","any");
assertMatch(p,"/animal/bird/eagle/bald","any");
assertMatch(p,"/","any");
}
/**
* Test the match order rules with a mixed Servlet and URI Template path specs
* <p>
* <ul>
* <li>Exact match</li>
* <li>Longest prefix match</li>
* <li>Longest suffix match</li>
* </ul>
*/
@Test
public void testMixedMatchUriOrder()
{
PathMappings<String> p = new PathMappings<>();
p.put(new ServletPathSpec("/"),"default");
p.put(new ServletPathSpec("/animal/bird/*"),"birds");
p.put(new ServletPathSpec("/animal/fish/*"),"fishes");
p.put(new ServletPathSpec("/animal/*"),"animals");
p.put(new UriTemplatePathSpec("/animal/{type}/{name}/chat"),"animalChat");
p.put(new UriTemplatePathSpec("/animal/{type}/{name}/cam"),"animalCam");
p.put(new UriTemplatePathSpec("/entrance/cam"),"entranceCam");
// dumpMappings(p);
assertMatch(p,"/animal/bird/eagle","birds");
assertMatch(p,"/animal/fish/bass/sea","fishes");
assertMatch(p,"/animal/peccary/javalina/evolution","animals");
assertMatch(p,"/","default");
assertMatch(p,"/animal/bird/eagle/chat","animalChat");
assertMatch(p,"/animal/bird/penguin/chat","animalChat");
assertMatch(p,"/animal/fish/trout/cam","animalCam");
assertMatch(p,"/entrance/cam","entranceCam");
}
/**
* Test the match order rules for URI Template based specs
* <p>
* <ul>
* <li>Exact match</li>
* <li>Longest prefix match</li>
* <li>Longest suffix match</li>
* </ul>
*/
@Test
public void testUriTemplateMatchOrder()
{
PathMappings<String> p = new PathMappings<>();
p.put(new UriTemplatePathSpec("/a/{var}/c"),"endpointA");
p.put(new UriTemplatePathSpec("/a/b/c"),"endpointB");
p.put(new UriTemplatePathSpec("/a/{var1}/{var2}"),"endpointC");
p.put(new UriTemplatePathSpec("/{var1}/d"),"endpointD");
p.put(new UriTemplatePathSpec("/b/{var2}"),"endpointE");
// dumpMappings(p);
assertMatch(p,"/a/b/c","endpointB");
assertMatch(p,"/a/d/c","endpointA");
assertMatch(p,"/a/x/y","endpointC");
assertMatch(p,"/b/d","endpointE");
}
@Test
public void testPathMap() throws Exception
{
PathMappings<String> p = new PathMappings<>();
p.put(new ServletPathSpec("/abs/path"), "1");
p.put(new ServletPathSpec("/abs/path/longer"), "2");
p.put(new ServletPathSpec("/animal/bird/*"), "3");
p.put(new ServletPathSpec("/animal/fish/*"), "4");
p.put(new ServletPathSpec("/animal/*"), "5");
p.put(new ServletPathSpec("*.tar.gz"), "6");
p.put(new ServletPathSpec("*.gz"), "7");
p.put(new ServletPathSpec("/"), "8");
// p.put(new ServletPathSpec("/XXX:/YYY"), "9"); // special syntax from Jetty 3.1.x
p.put(new ServletPathSpec(""), "10");
p.put(new ServletPathSpec("/\u20ACuro/*"), "11");
assertEquals("pathMatch exact", "/Foo/bar", new ServletPathSpec("/Foo/bar").getPathMatch("/Foo/bar"));
assertEquals("pathMatch prefix", "/Foo", new ServletPathSpec("/Foo/*").getPathMatch("/Foo/bar"));
assertEquals("pathMatch prefix", "/Foo", new ServletPathSpec("/Foo/*").getPathMatch("/Foo/"));
assertEquals("pathMatch prefix", "/Foo", new ServletPathSpec("/Foo/*").getPathMatch("/Foo"));
assertEquals("pathMatch suffix", "/Foo/bar.ext", new ServletPathSpec("*.ext").getPathMatch("/Foo/bar.ext"));
assertEquals("pathMatch default", "/Foo/bar.ext", new ServletPathSpec("/").getPathMatch("/Foo/bar.ext"));
assertEquals("pathInfo exact", null, new ServletPathSpec("/Foo/bar").getPathInfo("/Foo/bar"));
assertEquals("pathInfo prefix", "/bar", new ServletPathSpec("/Foo/*").getPathInfo("/Foo/bar"));
assertEquals("pathInfo prefix", "/*", new ServletPathSpec("/Foo/*").getPathInfo("/Foo/*"));
assertEquals("pathInfo prefix", "/", new ServletPathSpec("/Foo/*").getPathInfo("/Foo/"));
assertEquals("pathInfo prefix", null, new ServletPathSpec("/Foo/*").getPathInfo("/Foo"));
assertEquals("pathInfo suffix", null, new ServletPathSpec("*.ext").getPathInfo("/Foo/bar.ext"));
assertEquals("pathInfo default", null, new ServletPathSpec("/").getPathInfo("/Foo/bar.ext"));
p.put(new ServletPathSpec("/*"), "0");
// assertEquals("Get absolute path", "1", p.get("/abs/path"));
assertEquals("Match absolute path", "/abs/path", p.getMatch("/abs/path").getPathSpec().pathSpec);
assertEquals("Match absolute path", "1", p.getMatch("/abs/path").getResource());
assertEquals("Mismatch absolute path", "0", p.getMatch("/abs/path/xxx").getResource());
assertEquals("Mismatch absolute path", "0", p.getMatch("/abs/pith").getResource());
assertEquals("Match longer absolute path", "2", p.getMatch("/abs/path/longer").getResource());
assertEquals("Not exact absolute path", "0", p.getMatch("/abs/path/").getResource());
assertEquals("Not exact absolute path", "0", p.getMatch("/abs/path/xxx").getResource());
assertEquals("Match longest prefix", "3", p.getMatch("/animal/bird/eagle/bald").getResource());
assertEquals("Match longest prefix", "4", p.getMatch("/animal/fish/shark/grey").getResource());
assertEquals("Match longest prefix", "5", p.getMatch("/animal/insect/bug").getResource());
assertEquals("mismatch exact prefix", "5", p.getMatch("/animal").getResource());
assertEquals("mismatch exact prefix", "5", p.getMatch("/animal/").getResource());
assertEquals("Match longest suffix", "0", p.getMatch("/suffix/path.tar.gz").getResource());
assertEquals("Match longest suffix", "0", p.getMatch("/suffix/path.gz").getResource());
assertEquals("prefix rather than suffix", "5", p.getMatch("/animal/path.gz").getResource());
assertEquals("default", "0", p.getMatch("/Other/path").getResource());
assertEquals("pathMatch /*", "", new ServletPathSpec("/*").getPathMatch("/xxx/zzz"));
assertEquals("pathInfo /*", "/xxx/zzz", new ServletPathSpec("/*").getPathInfo("/xxx/zzz"));
assertTrue("match /", new ServletPathSpec("/").matches("/anything"));
assertTrue("match /*", new ServletPathSpec("/*").matches("/anything"));
assertTrue("match /foo", new ServletPathSpec("/foo").matches("/foo"));
assertTrue("!match /foo", !new ServletPathSpec("/foo").matches("/bar"));
assertTrue("match /foo/*", new ServletPathSpec("/foo/*").matches("/foo"));
assertTrue("match /foo/*", new ServletPathSpec("/foo/*").matches("/foo/"));
assertTrue("match /foo/*", new ServletPathSpec("/foo/*").matches("/foo/anything"));
assertTrue("!match /foo/*", !new ServletPathSpec("/foo/*").matches("/bar"));
assertTrue("!match /foo/*", !new ServletPathSpec("/foo/*").matches("/bar/"));
assertTrue("!match /foo/*", !new ServletPathSpec("/foo/*").matches("/bar/anything"));
assertTrue("match *.foo", new ServletPathSpec("*.foo").matches("anything.foo"));
assertTrue("!match *.foo", !new ServletPathSpec("*.foo").matches("anything.bar"));
assertEquals("match / with ''", "10", p.getMatch("/").getResource());
assertTrue("match \"\"", new ServletPathSpec("").matches("/"));
}
/**
* See JIRA issue: JETTY-88.
* @throws Exception failed test
*/
@Test
public void testPathMappingsOnlyMatchOnDirectoryNames() throws Exception
{
ServletPathSpec spec = new ServletPathSpec("/xyz/*");
PathSpecAssert.assertMatch(spec, "/xyz");
PathSpecAssert.assertMatch(spec, "/xyz/");
PathSpecAssert.assertMatch(spec, "/xyz/123");
PathSpecAssert.assertMatch(spec, "/xyz/123/");
PathSpecAssert.assertMatch(spec, "/xyz/123.txt");
PathSpecAssert.assertNotMatch(spec, "/xyz123");
PathSpecAssert.assertNotMatch(spec, "/xyz123;jessionid=99");
PathSpecAssert.assertNotMatch(spec, "/xyz123/");
PathSpecAssert.assertNotMatch(spec, "/xyz123/456");
PathSpecAssert.assertNotMatch(spec, "/xyz.123");
PathSpecAssert.assertNotMatch(spec, "/xyz;123"); // as if the ; was encoded and part of the path
PathSpecAssert.assertNotMatch(spec, "/xyz?123"); // as if the ? was encoded and part of the path
}
@Test
public void testPrecidenceVsOrdering() throws Exception
{
PathMappings<String> p = new PathMappings<>();
p.put(new ServletPathSpec("/dump/gzip/*"),"prefix");
p.put(new ServletPathSpec("*.txt"),"suffix");
assertEquals(null,p.getMatch("/foo/bar"));
assertEquals("prefix",p.getMatch("/dump/gzip/something").getResource());
assertEquals("suffix",p.getMatch("/foo/something.txt").getResource());
assertEquals("prefix",p.getMatch("/dump/gzip/something.txt").getResource());
p = new PathMappings<>();
p.put(new ServletPathSpec("*.txt"),"suffix");
p.put(new ServletPathSpec("/dump/gzip/*"),"prefix");
assertEquals(null,p.getMatch("/foo/bar"));
assertEquals("prefix",p.getMatch("/dump/gzip/something").getResource());
assertEquals("suffix",p.getMatch("/foo/something.txt").getResource());
assertEquals("prefix",p.getMatch("/dump/gzip/something.txt").getResource());
}
}

View File

@ -0,0 +1,37 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;
public class PathSpecAssert
{
public static void assertMatch(PathSpec spec, String path)
{
boolean match = spec.matches(path);
assertThat(spec.getClass().getSimpleName() + " '" + spec + "' should match path '" + path + "'", match, is(true));
}
public static void assertNotMatch(PathSpec spec, String path)
{
boolean match = spec.matches(path);
assertThat(spec.getClass().getSimpleName() + " '" + spec + "' should not match path '" + path + "'", match, is(false));
}
}

View File

@ -0,0 +1,135 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import org.junit.Test;
public class RegexPathSpecTest
{
public static void assertMatches(PathSpec spec, String path)
{
String msg = String.format("Spec(\"%s\").matches(\"%s\")",spec.getDeclaration(),path);
assertThat(msg,spec.matches(path),is(true));
}
public static void assertNotMatches(PathSpec spec, String path)
{
String msg = String.format("!Spec(\"%s\").matches(\"%s\")",spec.getDeclaration(),path);
assertThat(msg,spec.matches(path),is(false));
}
@Test
public void testExactSpec()
{
RegexPathSpec spec = new RegexPathSpec("^/a$");
assertEquals("Spec.pathSpec","^/a$",spec.getDeclaration());
assertEquals("Spec.pattern","^/a$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",1,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.EXACT,spec.group);
assertMatches(spec,"/a");
assertNotMatches(spec,"/aa");
assertNotMatches(spec,"/a/");
}
@Test
public void testMiddleSpec()
{
RegexPathSpec spec = new RegexPathSpec("^/rest/([^/]*)/list$");
assertEquals("Spec.pathSpec","^/rest/([^/]*)/list$",spec.getDeclaration());
assertEquals("Spec.pattern","^/rest/([^/]*)/list$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",3,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.MIDDLE_GLOB,spec.group);
assertMatches(spec,"/rest/api/list");
assertMatches(spec,"/rest/1.0/list");
assertMatches(spec,"/rest/2.0/list");
assertMatches(spec,"/rest/accounts/list");
assertNotMatches(spec,"/a");
assertNotMatches(spec,"/aa");
assertNotMatches(spec,"/aa/bb");
assertNotMatches(spec,"/rest/admin/delete");
assertNotMatches(spec,"/rest/list");
}
@Test
public void testMiddleSpecNoGrouping()
{
RegexPathSpec spec = new RegexPathSpec("^/rest/[^/]+/list$");
assertEquals("Spec.pathSpec","^/rest/[^/]+/list$",spec.getDeclaration());
assertEquals("Spec.pattern","^/rest/[^/]+/list$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",3,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.MIDDLE_GLOB,spec.group);
assertMatches(spec,"/rest/api/list");
assertMatches(spec,"/rest/1.0/list");
assertMatches(spec,"/rest/2.0/list");
assertMatches(spec,"/rest/accounts/list");
assertNotMatches(spec,"/a");
assertNotMatches(spec,"/aa");
assertNotMatches(spec,"/aa/bb");
assertNotMatches(spec,"/rest/admin/delete");
assertNotMatches(spec,"/rest/list");
}
@Test
public void testPrefixSpec()
{
RegexPathSpec spec = new RegexPathSpec("^/a/(.*)$");
assertEquals("Spec.pathSpec","^/a/(.*)$",spec.getDeclaration());
assertEquals("Spec.pattern","^/a/(.*)$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",2,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.PREFIX_GLOB,spec.group);
assertMatches(spec,"/a/");
assertMatches(spec,"/a/b");
assertMatches(spec,"/a/b/c/d/e");
assertNotMatches(spec,"/a");
assertNotMatches(spec,"/aa");
assertNotMatches(spec,"/aa/bb");
}
@Test
public void testSuffixSpec()
{
RegexPathSpec spec = new RegexPathSpec("^(.*).do$");
assertEquals("Spec.pathSpec","^(.*).do$",spec.getDeclaration());
assertEquals("Spec.pattern","^(.*).do$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",0,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.SUFFIX_GLOB,spec.group);
assertMatches(spec,"/a.do");
assertMatches(spec,"/a/b/c.do");
assertMatches(spec,"/abcde.do");
assertMatches(spec,"/abc/efg.do");
assertNotMatches(spec,"/a");
assertNotMatches(spec,"/aa");
assertNotMatches(spec,"/aa/bb");
assertNotMatches(spec,"/aa/bb.do/more");
}
}

View File

@ -0,0 +1,101 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
/**
* Tests of {@link PathMappings#getMatches(String)}
*/
@RunWith(Parameterized.class)
public class ServletPathSpecMatchListTest
{
@Parameters(name="{0} = {1}")
public static List<String[]> testCases()
{
String data[][] = new String[][] {
// From old PathMapTest
{ "All matches", "/animal/bird/path.tar.gz", "[/animal/bird/*=birds, /animal/*=animals, *.tar.gz=tarball, *.gz=gzipped, /=default]"},
{ "Dir matches", "/animal/fish/", "[/animal/fish/*=fishes, /animal/*=animals, /=default]"},
{ "Dir matches", "/animal/fish", "[/animal/fish/*=fishes, /animal/*=animals, /=default]"},
{ "Root matches", "/", "[=root, /=default]"},
{ "Dir matches", "", "[/=default]"}
};
return Arrays.asList(data);
}
private static PathMappings<String> mappings;
static {
mappings = new PathMappings<>();
// From old PathMapTest
mappings.put(new ServletPathSpec("/abs/path"),"abspath"); // 1
mappings.put(new ServletPathSpec("/abs/path/longer"),"longpath"); // 2
mappings.put(new ServletPathSpec("/animal/bird/*"),"birds"); // 3
mappings.put(new ServletPathSpec("/animal/fish/*"),"fishes"); // 4
mappings.put(new ServletPathSpec("/animal/*"),"animals"); // 5
mappings.put(new ServletPathSpec("*.tar.gz"),"tarball"); // 6
mappings.put(new ServletPathSpec("*.gz"),"gzipped"); // 7
mappings.put(new ServletPathSpec("/"),"default"); // 8
// 9 was the old Jetty ":" spec delimited case (no longer valid)
mappings.put(new ServletPathSpec(""),"root"); // 10
mappings.put(new ServletPathSpec("/\u20ACuro/*"),"money"); // 11
}
@Parameter(0)
public String message;
@Parameter(1)
public String inputPath;
@Parameter(2)
public String expectedListing;
@Test
public void testGetMatches()
{
List<MappedResource<String>> matches = mappings.getMatches(inputPath);
StringBuilder actual = new StringBuilder();
actual.append('[');
boolean delim = false;
for (MappedResource<String> res : matches)
{
if (delim)
actual.append(", ");
actual.append(res.getPathSpec().pathSpec).append('=').append(res.getResource());
delim = true;
}
actual.append(']');
assertThat(message + " on [" + inputPath + "]",actual.toString(),is(expectedListing));
}
}

View File

@ -0,0 +1,103 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
/**
* Tests of {@link PathMappings#getMatch(String)}, with a focus on correct mapping selection order
*/
@RunWith(Parameterized.class)
public class ServletPathSpecOrderTest
{
@Parameters(name="{0} = {1}")
public static List<String[]> testCases()
{
String data[][] = new String[][] {
// From old PathMapTest
{"/abs/path","abspath"},
{"/abs/path/xxx","default"},
{"/abs/pith","default"},
{"/abs/path/longer","longpath"},
{"/abs/path/","default"},
{"/abs/path/foo","default"},
{"/animal/bird/eagle/bald","birds"},
{"/animal/fish/shark/hammerhead","fishes"},
{"/animal/insect/ladybug","animals"},
{"/animal","animals"},
{"/animal/","animals"},
{"/animal/other","animals"},
{"/animal/*","animals"},
{"/downloads/distribution.tar.gz","tarball"},
{"/downloads/script.gz","gzipped"},
{"/animal/arhive.gz","animals"},
{"/Other/path","default"},
{"/\u20ACuro/path","money"},
{"/","root"},
// Extra tests
{"/downloads/readme.txt","default"},
{"/downloads/logs.tgz","default"},
{"/main.css","default"}
};
return Arrays.asList(data);
}
private static PathMappings<String> mappings;
static {
mappings = new PathMappings<>();
// From old PathMapTest
mappings.put(new ServletPathSpec("/abs/path"),"abspath"); // 1
mappings.put(new ServletPathSpec("/abs/path/longer"),"longpath"); // 2
mappings.put(new ServletPathSpec("/animal/bird/*"),"birds"); // 3
mappings.put(new ServletPathSpec("/animal/fish/*"),"fishes"); // 4
mappings.put(new ServletPathSpec("/animal/*"),"animals"); // 5
mappings.put(new ServletPathSpec("*.tar.gz"),"tarball"); // 6
mappings.put(new ServletPathSpec("*.gz"),"gzipped"); // 7
mappings.put(new ServletPathSpec("/"),"default"); // 8
// 9 was the old Jetty ":" spec delimited case (no longer valid)
mappings.put(new ServletPathSpec(""),"root"); // 10
mappings.put(new ServletPathSpec("/\u20ACuro/*"),"money"); // 11
}
@Parameter(0)
public String inputPath;
@Parameter(1)
public String expectedResource;
@Test
public void testMatch()
{
assertThat("Match on ["+ inputPath+ "]", mappings.getMatch(inputPath).getResource(), is(expectedResource));
}
}

View File

@ -0,0 +1,188 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import org.junit.Test;
public class ServletPathSpecTest
{
private void assertBadServletPathSpec(String pathSpec)
{
try
{
new ServletPathSpec(pathSpec);
fail("Expected IllegalArgumentException for a bad servlet pathspec on: " + pathSpec);
}
catch (IllegalArgumentException e)
{
// expected path
System.out.println(e);
}
}
private void assertMatches(ServletPathSpec spec, String path)
{
String msg = String.format("Spec(\"%s\").matches(\"%s\")",spec.getDeclaration(),path);
assertThat(msg,spec.matches(path),is(true));
}
private void assertNotMatches(ServletPathSpec spec, String path)
{
String msg = String.format("!Spec(\"%s\").matches(\"%s\")",spec.getDeclaration(),path);
assertThat(msg,spec.matches(path),is(false));
}
@Test
public void testBadServletPathSpecA()
{
assertBadServletPathSpec("foo");
}
@Test
public void testBadServletPathSpecB()
{
assertBadServletPathSpec("/foo/*.do");
}
@Test
public void testBadServletPathSpecC()
{
assertBadServletPathSpec("foo/*.do");
}
@Test
public void testBadServletPathSpecD()
{
assertBadServletPathSpec("foo/*.*do");
}
@Test
public void testBadServletPathSpecE()
{
assertBadServletPathSpec("*do");
}
@Test
public void testDefaultPathSpec()
{
ServletPathSpec spec = new ServletPathSpec("/");
assertEquals("Spec.pathSpec","/",spec.getDeclaration());
assertEquals("Spec.pathDepth",-1,spec.getPathDepth());
}
@Test
public void testExactPathSpec()
{
ServletPathSpec spec = new ServletPathSpec("/abs/path");
assertEquals("Spec.pathSpec","/abs/path",spec.getDeclaration());
assertEquals("Spec.pathDepth",2,spec.getPathDepth());
assertMatches(spec,"/abs/path");
assertNotMatches(spec,"/abs/path/");
assertNotMatches(spec,"/abs/path/more");
assertNotMatches(spec,"/foo");
assertNotMatches(spec,"/foo/abs/path");
assertNotMatches(spec,"/foo/abs/path/");
}
@Test
public void testGetPathInfo()
{
assertEquals("pathInfo exact",null,new ServletPathSpec("/Foo/bar").getPathInfo("/Foo/bar"));
assertEquals("pathInfo prefix","/bar",new ServletPathSpec("/Foo/*").getPathInfo("/Foo/bar"));
assertEquals("pathInfo prefix","/*",new ServletPathSpec("/Foo/*").getPathInfo("/Foo/*"));
assertEquals("pathInfo prefix","/",new ServletPathSpec("/Foo/*").getPathInfo("/Foo/"));
assertEquals("pathInfo prefix",null,new ServletPathSpec("/Foo/*").getPathInfo("/Foo"));
assertEquals("pathInfo suffix",null,new ServletPathSpec("*.ext").getPathInfo("/Foo/bar.ext"));
assertEquals("pathInfo default",null,new ServletPathSpec("/").getPathInfo("/Foo/bar.ext"));
assertEquals("pathInfo default","/xxx/zzz",new ServletPathSpec("/*").getPathInfo("/xxx/zzz"));
}
@Test
public void testNullPathSpec()
{
ServletPathSpec spec = new ServletPathSpec(null);
assertEquals("Spec.pathSpec","",spec.getDeclaration());
assertEquals("Spec.pathDepth",-1,spec.getPathDepth());
}
@Test
public void testRootPathSpec()
{
ServletPathSpec spec = new ServletPathSpec("");
assertEquals("Spec.pathSpec","",spec.getDeclaration());
assertEquals("Spec.pathDepth",-1,spec.getPathDepth());
}
@Test
public void testPathMatch()
{
assertEquals("pathMatch exact","/Foo/bar",new ServletPathSpec("/Foo/bar").getPathMatch("/Foo/bar"));
assertEquals("pathMatch prefix","/Foo",new ServletPathSpec("/Foo/*").getPathMatch("/Foo/bar"));
assertEquals("pathMatch prefix","/Foo",new ServletPathSpec("/Foo/*").getPathMatch("/Foo/"));
assertEquals("pathMatch prefix","/Foo",new ServletPathSpec("/Foo/*").getPathMatch("/Foo"));
assertEquals("pathMatch suffix","/Foo/bar.ext",new ServletPathSpec("*.ext").getPathMatch("/Foo/bar.ext"));
assertEquals("pathMatch default","/Foo/bar.ext",new ServletPathSpec("/").getPathMatch("/Foo/bar.ext"));
assertEquals("pathMatch default","",new ServletPathSpec("/*").getPathMatch("/xxx/zzz"));
}
@Test
public void testPrefixPathSpec()
{
ServletPathSpec spec = new ServletPathSpec("/downloads/*");
assertEquals("Spec.pathSpec","/downloads/*",spec.getDeclaration());
assertEquals("Spec.pathDepth",2,spec.getPathDepth());
assertMatches(spec,"/downloads/logo.jpg");
assertMatches(spec,"/downloads/distribution.tar.gz");
assertMatches(spec,"/downloads/distribution.tgz");
assertMatches(spec,"/downloads/distribution.zip");
assertMatches(spec,"/downloads");
assertEquals("Spec.pathInfo","/",spec.getPathInfo("/downloads/"));
assertEquals("Spec.pathInfo","/distribution.zip",spec.getPathInfo("/downloads/distribution.zip"));
assertEquals("Spec.pathInfo","/dist/9.0/distribution.tar.gz",spec.getPathInfo("/downloads/dist/9.0/distribution.tar.gz"));
}
@Test
public void testSuffixPathSpec()
{
ServletPathSpec spec = new ServletPathSpec("*.gz");
assertEquals("Spec.pathSpec","*.gz",spec.getDeclaration());
assertEquals("Spec.pathDepth",0,spec.getPathDepth());
assertMatches(spec,"/downloads/distribution.tar.gz");
assertMatches(spec,"/downloads/jetty.log.gz");
assertNotMatches(spec,"/downloads/distribution.zip");
assertNotMatches(spec,"/downloads/distribution.tgz");
assertNotMatches(spec,"/abs/path");
assertEquals("Spec.pathInfo",null,spec.getPathInfo("/downloads/distribution.tar.gz"));
}
}

View File

@ -0,0 +1,87 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
import static org.junit.Assert.fail;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
/**
* Tests for bad path specs on ServerEndpoint Path Param / URI Template
*/
@RunWith(Parameterized.class)
public class UriTemplatePathSpecBadSpecsTest
{
private static void bad(List<String[]> data, String str)
{
data.add(new String[]
{ str });
}
@Parameters
public static Collection<String[]> data()
{
List<String[]> data = new ArrayList<>();
bad(data,"/a/b{var}"); // bad syntax - variable does not encompass whole path segment
bad(data,"a/{var}"); // bad syntax - no start slash
bad(data,"/a/{var/b}"); // path segment separator in variable name
bad(data,"/{var}/*"); // bad syntax - no globs allowed
bad(data,"/{var}.do"); // bad syntax - variable does not encompass whole path segment
bad(data,"/a/{var*}"); // use of glob character not allowed in variable name
bad(data,"/a/{}"); // bad syntax - no variable name
// MIGHT BE ALLOWED bad(data,"/a/{---}"); // no alpha in variable name
bad(data,"{var}"); // bad syntax - no start slash
bad(data,"/a/{my special variable}"); // bad syntax - space in variable name
bad(data,"/a/{var}/{var}"); // variable name duplicate
// MIGHT BE ALLOWED bad(data,"/a/{var}/{Var}/{vAR}"); // variable name duplicated (diff case)
bad(data,"/a/../../../{var}"); // path navigation not allowed
bad(data,"/a/./{var}"); // path navigation not allowed
bad(data,"/a//{var}"); // bad syntax - double path slash (no path segment)
return data;
}
private String pathSpec;
public UriTemplatePathSpecBadSpecsTest(String pathSpec)
{
this.pathSpec = pathSpec;
}
@Test
public void testBadPathSpec()
{
try
{
new UriTemplatePathSpec(this.pathSpec);
fail("Expected IllegalArgumentException for a bad PathParam pathspec on: " + pathSpec);
}
catch (IllegalArgumentException e)
{
// expected path
System.out.println(e.getMessage());
}
}
}

View File

@ -0,0 +1,284 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.http.pathmap;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import java.util.Map;
import org.junit.Test;
/**
* Tests for URI Template Path Specs
*/
public class UriTemplatePathSpecTest
{
private void assertDetectedVars(UriTemplatePathSpec spec, String... expectedVars)
{
String prefix = String.format("Spec(\"%s\")",spec.getDeclaration());
assertEquals(prefix + ".variableCount",expectedVars.length,spec.getVariableCount());
assertEquals(prefix + ".variable.length",expectedVars.length,spec.getVariables().length);
for (int i = 0; i < expectedVars.length; i++)
{
assertEquals(String.format("%s.variable[%d]",prefix,i),expectedVars[i],spec.getVariables()[i]);
}
}
private void assertMatches(PathSpec spec, String path)
{
String msg = String.format("Spec(\"%s\").matches(\"%s\")",spec.getDeclaration(),path);
assertThat(msg,spec.matches(path),is(true));
}
private void assertNotMatches(PathSpec spec, String path)
{
String msg = String.format("!Spec(\"%s\").matches(\"%s\")",spec.getDeclaration(),path);
assertThat(msg,spec.matches(path),is(false));
}
@Test
public void testDefaultPathSpec()
{
UriTemplatePathSpec spec = new UriTemplatePathSpec("/");
assertEquals("Spec.pathSpec","/",spec.getDeclaration());
assertEquals("Spec.pattern","^/$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",1,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.EXACT,spec.getGroup());
assertEquals("Spec.variableCount",0,spec.getVariableCount());
assertEquals("Spec.variable.length",0,spec.getVariables().length);
}
@Test
public void testExactOnePathSpec()
{
UriTemplatePathSpec spec = new UriTemplatePathSpec("/a");
assertEquals("Spec.pathSpec","/a",spec.getDeclaration());
assertEquals("Spec.pattern","^/a$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",1,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.EXACT,spec.getGroup());
assertMatches(spec,"/a");
assertMatches(spec,"/a?type=other");
assertNotMatches(spec,"/a/b");
assertNotMatches(spec,"/a/");
assertEquals("Spec.variableCount",0,spec.getVariableCount());
assertEquals("Spec.variable.length",0,spec.getVariables().length);
}
@Test
public void testExactPathSpec_TestWebapp()
{
UriTemplatePathSpec spec = new UriTemplatePathSpec("/deep.thought/");
assertEquals("Spec.pathSpec","/deep.thought/",spec.getDeclaration());
assertEquals("Spec.pattern","^/deep\\.thought/$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",1,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.EXACT,spec.getGroup());
assertMatches(spec,"/deep.thought/");
assertNotMatches(spec,"/deep.thought");
assertEquals("Spec.variableCount",0,spec.getVariableCount());
assertEquals("Spec.variable.length",0,spec.getVariables().length);
}
@Test
public void testExactTwoPathSpec()
{
UriTemplatePathSpec spec = new UriTemplatePathSpec("/a/b");
assertEquals("Spec.pathSpec","/a/b",spec.getDeclaration());
assertEquals("Spec.pattern","^/a/b$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",2,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.EXACT,spec.getGroup());
assertEquals("Spec.variableCount",0,spec.getVariableCount());
assertEquals("Spec.variable.length",0,spec.getVariables().length);
assertMatches(spec,"/a/b");
assertNotMatches(spec,"/a/b/");
assertNotMatches(spec,"/a/");
assertNotMatches(spec,"/a/bb");
}
@Test
public void testMiddleVarPathSpec()
{
UriTemplatePathSpec spec = new UriTemplatePathSpec("/a/{var}/c");
assertEquals("Spec.pathSpec","/a/{var}/c",spec.getDeclaration());
assertEquals("Spec.pattern","^/a/([^/]+)/c$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",3,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.MIDDLE_GLOB,spec.getGroup());
assertDetectedVars(spec,"var");
assertMatches(spec,"/a/b/c");
assertMatches(spec,"/a/zz/c");
assertMatches(spec,"/a/hello+world/c");
assertNotMatches(spec,"/a/bc");
assertNotMatches(spec,"/a/b/");
assertNotMatches(spec,"/a/b");
Map<String, String> mapped = spec.getPathParams("/a/b/c");
assertThat("Spec.pathParams",mapped,notNullValue());
assertThat("Spec.pathParams.size",mapped.size(),is(1));
assertEquals("Spec.pathParams[var]","b",mapped.get("var"));
}
@Test
public void testOneVarPathSpec()
{
UriTemplatePathSpec spec = new UriTemplatePathSpec("/a/{foo}");
assertEquals("Spec.pathSpec","/a/{foo}",spec.getDeclaration());
assertEquals("Spec.pattern","^/a/([^/]+)$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",2,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.PREFIX_GLOB,spec.getGroup());
assertDetectedVars(spec,"foo");
assertMatches(spec,"/a/b");
assertNotMatches(spec,"/a/");
assertNotMatches(spec,"/a");
Map<String, String> mapped = spec.getPathParams("/a/b");
assertThat("Spec.pathParams",mapped,notNullValue());
assertThat("Spec.pathParams.size",mapped.size(),is(1));
assertEquals("Spec.pathParams[foo]","b",mapped.get("foo"));
}
@Test
public void testOneVarSuffixPathSpec()
{
UriTemplatePathSpec spec = new UriTemplatePathSpec("/{var}/b/c");
assertEquals("Spec.pathSpec","/{var}/b/c",spec.getDeclaration());
assertEquals("Spec.pattern","^/([^/]+)/b/c$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",3,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.SUFFIX_GLOB,spec.getGroup());
assertDetectedVars(spec,"var");
assertMatches(spec,"/a/b/c");
assertMatches(spec,"/az/b/c");
assertMatches(spec,"/hello+world/b/c");
assertNotMatches(spec,"/a/bc");
assertNotMatches(spec,"/a/b/");
assertNotMatches(spec,"/a/b");
Map<String, String> mapped = spec.getPathParams("/a/b/c");
assertThat("Spec.pathParams",mapped,notNullValue());
assertThat("Spec.pathParams.size",mapped.size(),is(1));
assertEquals("Spec.pathParams[var]","a",mapped.get("var"));
}
@Test
public void testTwoVarComplexInnerPathSpec()
{
UriTemplatePathSpec spec = new UriTemplatePathSpec("/a/{var1}/c/{var2}/e");
assertEquals("Spec.pathSpec","/a/{var1}/c/{var2}/e",spec.getDeclaration());
assertEquals("Spec.pattern","^/a/([^/]+)/c/([^/]+)/e$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",5,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.MIDDLE_GLOB,spec.getGroup());
assertDetectedVars(spec,"var1","var2");
assertMatches(spec,"/a/b/c/d/e");
assertNotMatches(spec,"/a/bc/d/e");
assertNotMatches(spec,"/a/b/d/e");
assertNotMatches(spec,"/a/b//d/e");
Map<String, String> mapped = spec.getPathParams("/a/b/c/d/e");
assertThat("Spec.pathParams",mapped,notNullValue());
assertThat("Spec.pathParams.size",mapped.size(),is(2));
assertEquals("Spec.pathParams[var1]","b",mapped.get("var1"));
assertEquals("Spec.pathParams[var2]","d",mapped.get("var2"));
}
@Test
public void testTwoVarComplexOuterPathSpec()
{
UriTemplatePathSpec spec = new UriTemplatePathSpec("/{var1}/b/{var2}/{var3}");
assertEquals("Spec.pathSpec","/{var1}/b/{var2}/{var3}",spec.getDeclaration());
assertEquals("Spec.pattern","^/([^/]+)/b/([^/]+)/([^/]+)$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",4,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.MIDDLE_GLOB,spec.getGroup());
assertDetectedVars(spec,"var1","var2","var3");
assertMatches(spec,"/a/b/c/d");
assertNotMatches(spec,"/a/bc/d/e");
assertNotMatches(spec,"/a/c/d/e");
assertNotMatches(spec,"/a//d/e");
Map<String, String> mapped = spec.getPathParams("/a/b/c/d");
assertThat("Spec.pathParams",mapped,notNullValue());
assertThat("Spec.pathParams.size",mapped.size(),is(3));
assertEquals("Spec.pathParams[var1]","a",mapped.get("var1"));
assertEquals("Spec.pathParams[var2]","c",mapped.get("var2"));
assertEquals("Spec.pathParams[var3]","d",mapped.get("var3"));
}
@Test
public void testTwoVarPrefixPathSpec()
{
UriTemplatePathSpec spec = new UriTemplatePathSpec("/a/{var1}/{var2}");
assertEquals("Spec.pathSpec","/a/{var1}/{var2}",spec.getDeclaration());
assertEquals("Spec.pattern","^/a/([^/]+)/([^/]+)$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",3,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.PREFIX_GLOB,spec.getGroup());
assertDetectedVars(spec,"var1","var2");
assertMatches(spec,"/a/b/c");
assertNotMatches(spec,"/a/bc");
assertNotMatches(spec,"/a/b/");
assertNotMatches(spec,"/a/b");
Map<String, String> mapped = spec.getPathParams("/a/b/c");
assertThat("Spec.pathParams",mapped,notNullValue());
assertThat("Spec.pathParams.size",mapped.size(),is(2));
assertEquals("Spec.pathParams[var1]","b",mapped.get("var1"));
assertEquals("Spec.pathParams[var2]","c",mapped.get("var2"));
}
@Test
public void testVarOnlyPathSpec()
{
UriTemplatePathSpec spec = new UriTemplatePathSpec("/{var1}");
assertEquals("Spec.pathSpec","/{var1}",spec.getDeclaration());
assertEquals("Spec.pattern","^/([^/]+)$",spec.getPattern().pattern());
assertEquals("Spec.pathDepth",1,spec.getPathDepth());
assertEquals("Spec.group",PathSpecGroup.PREFIX_GLOB,spec.getGroup());
assertDetectedVars(spec,"var1");
assertMatches(spec,"/a");
assertNotMatches(spec,"/");
assertNotMatches(spec,"/a/b");
assertNotMatches(spec,"/a/b/c");
Map<String, String> mapped = spec.getPathParams("/a");
assertThat("Spec.pathParams",mapped,notNullValue());
assertThat("Spec.pathParams.size",mapped.size(),is(1));
assertEquals("Spec.pathParams[var1]","a",mapped.get("var1"));
}
}

View File

@ -36,7 +36,7 @@ import org.eclipse.jetty.http.HttpHeader;
import org.eclipse.jetty.http.HttpMethod;
import org.eclipse.jetty.http.HttpVersion;
import org.eclipse.jetty.http.MimeTypes;
import org.eclipse.jetty.http.PathMap;
import org.eclipse.jetty.http.pathmap.PathSpecSet;
import org.eclipse.jetty.server.HttpOutput;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.handler.HandlerWrapper;
@ -72,9 +72,9 @@ public class GzipHandler extends HandlerWrapper implements GzipFactory
// non-static, as other GzipHandler instances may have different configurations
private final ThreadLocal<Deflater> _deflater = new ThreadLocal<Deflater>();
private final IncludeExclude<String> _agentPatterns=new IncludeExclude<>(RegexSet.class,RegexSet.MATCHER);
private final IncludeExclude<String> _agentPatterns=new IncludeExclude<>(RegexSet.class);
private final IncludeExclude<String> _methods = new IncludeExclude<>();
private final IncludeExclude<String> _paths = new IncludeExclude<>(PathMap.PathSet.class,PathMap.PathSet.MATCHER);
private final IncludeExclude<String> _paths = new IncludeExclude<>(PathSpecSet.class);
private final IncludeExclude<String> _mimeTypes = new IncludeExclude<>();
private HttpField _vary;

View File

@ -20,6 +20,7 @@ package org.eclipse.jetty.servlet.listener;
import java.lang.reflect.Field;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.servlet.ServletContextEvent;
@ -98,7 +99,7 @@ public class ELContextCleaner implements ServletContextListener
if (!properties.isAccessible())
properties.setAccessible(true);
ConcurrentHashMap<Class<?>, Object> map = (ConcurrentHashMap<Class<?>, Object>) properties.get(null);
Map map = (Map) properties.get(null);
if (map == null)
return;

View File

@ -18,7 +18,10 @@
package org.eclipse.jetty.servlet;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import java.io.ByteArrayInputStream;
@ -26,6 +29,7 @@ import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.zip.GZIPInputStream;
import javax.servlet.ServletException;
@ -198,4 +202,16 @@ public class GzipHandlerTest
assertEquals(__icontent, testOut.toString("UTF8"));
}
@Test
public void testAddGetPaths()
{
GzipHandler gzip = new GzipHandler();
gzip.addIncludedPaths("/foo");
gzip.addIncludedPaths("^/bar.*$");
String[] includedPaths = gzip.getIncludedPaths();
assertThat("Included Paths.size", includedPaths.length, is(2));
assertThat("Included Paths", Arrays.asList(includedPaths), contains("/foo","^/bar.*$"));
}
}

View File

@ -20,7 +20,6 @@ package org.eclipse.jetty.util;
import java.util.HashSet;
import java.util.Set;
import java.util.function.BiFunction;
/** Utility class to maintain a set of inclusions and exclusions.
@ -35,29 +34,57 @@ import java.util.function.BiFunction;
public class IncludeExclude<ITEM>
{
private final Set<ITEM> _includes;
private final Predicate<ITEM> _includePredicate;
private final Set<ITEM> _excludes;
private final BiFunction<Set<ITEM>,ITEM, Boolean> _matcher;
private final Predicate<ITEM> _excludePredicate;
private static class SetContainsPredicate<ITEM> implements Predicate<ITEM>
{
private final Set<ITEM> set;
public SetContainsPredicate(Set<ITEM> set)
{
this.set = set;
}
@Override
public boolean test(ITEM item)
{
return set.contains(item);
}
}
/**
* Default constructor over {@link HashSet}
*/
public IncludeExclude()
{
this(HashSet.class,null);
this(HashSet.class);
}
/**
* Construct an IncludeExclude
* @param setClass The type of {@link Set} to using internally
* @param matcher A function to test if a passed ITEM is matched by the passed SET, or null to use {@link Set#contains(Object)}
* @param predicate A predicate function to test if a passed ITEM is matched by the passed SET}
*/
public <SET extends Set<ITEM>> IncludeExclude(Class<SET> setClass, BiFunction<SET,ITEM, Boolean> matcher)
public <SET extends Set<ITEM>> IncludeExclude(Class<SET> setClass)
{
try
{
_includes = setClass.newInstance();
_excludes = setClass.newInstance();
_matcher = (BiFunction<Set<ITEM>,ITEM, Boolean>)matcher;
if(_includes instanceof Predicate) {
_includePredicate = (Predicate<ITEM>)_includes;
} else {
_includePredicate = new SetContainsPredicate<>(_includes);
}
if(_excludes instanceof Predicate) {
_excludePredicate = (Predicate<ITEM>)_excludes;
} else {
_excludePredicate = new SetContainsPredicate<>(_excludes);
}
}
catch (InstantiationException | IllegalAccessException e)
{
@ -65,6 +92,22 @@ public class IncludeExclude<ITEM>
}
}
/**
* Construct an IncludeExclude
*
* @param includeSet the Set of items that represent the included space
* @param includePredicate the Predicate for included item testing (null for simple {@link Set#contains(Object)} test)
* @param excludeSet the Set of items that represent the excluded space
* @param excludePredicate the Predicate for excluded item testing (null for simple {@link Set#contains(Object)} test)
*/
public <SET extends Set<ITEM>> IncludeExclude(Set<ITEM> includeSet, Predicate<ITEM> includePredicate, Set<ITEM> excludeSet, Predicate<ITEM> excludePredicate)
{
_includes = includeSet;
_includePredicate = includePredicate;
_excludes = excludeSet;
_excludePredicate = excludePredicate;
}
public void include(ITEM element)
{
_includes.add(element);
@ -89,15 +132,9 @@ public class IncludeExclude<ITEM>
public boolean matches(ITEM e)
{
if (_matcher==null)
{
if (_includes.size()>0 && !_includes.contains(e))
if (!_includes.isEmpty() && !_includePredicate.test(e))
return false;
return !_excludes.contains(e);
}
if (_includes.size()>0 && !_matcher.apply(_includes,e))
return false;
return !_matcher.apply(_excludes,e);
return !_excludePredicate.test(e);
}
public int size()
@ -124,6 +161,6 @@ public class IncludeExclude<ITEM>
@Override
public String toString()
{
return String.format("%s@%x{i=%s,e=%s,m=%s}",this.getClass().getSimpleName(),hashCode(),_includes,_excludes,_matcher);
return String.format("%s@%x{i=%s,ip=%s,e=%s,ep=%s}",this.getClass().getSimpleName(),hashCode(),_includes,_includePredicate,_excludes,_excludePredicate);
}
}

View File

@ -0,0 +1,31 @@
//
// ========================================================================
// Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.util;
/**
* Temporary implementation of Java 8's <code>java.util.function.Predicate</code>
* <p>
* To be removed for Java 8 only versions of Jetty.
*
* @param <ITEM> the item to test
*/
public interface Predicate<ITEM>
{
boolean test(ITEM item);
}

View File

@ -23,18 +23,15 @@ import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.regex.Pattern;
/**
* A Set of Regular expressions strings.
* <p>
* Provides the efficient {@link #matches(String)} method to check for a match against all the combined Regex's
*/
public class RegexSet extends AbstractSet<String>
public class RegexSet extends AbstractSet<String> implements Predicate<String>
{
public static final BiFunction<RegexSet,String,Boolean> MATCHER=(rs,p)->{return rs.matches(p);};
private final Set<String> _patterns=new HashSet<String>();
private final Set<String> _unmodifiable=Collections.unmodifiableSet(_patterns);
private Pattern _pattern;
@ -99,6 +96,12 @@ public class RegexSet extends AbstractSet<String>
_pattern = Pattern.compile(builder.toString());
}
@Override
public boolean test(String s)
{
return _pattern!=null && _pattern.matcher(s).matches();
}
public boolean matches(String s)
{
return _pattern!=null && _pattern.matcher(s).matches();

View File

@ -20,7 +20,9 @@ package org.eclipse.jetty.util;
import org.junit.Test;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
public class IncludeExcludeTest
{
@ -29,8 +31,8 @@ public class IncludeExcludeTest
{
IncludeExclude<String> ie = new IncludeExclude<>();
assertEquals(0,ie.size());
assertEquals(true,ie.matches("foo"));
assertThat("Empty IncludeExclude", ie.size(), is(0));
assertThat("Matches 'foo'",ie.matches("foo"),is(true));
}
@Test
@ -40,7 +42,7 @@ public class IncludeExcludeTest
ie.include("foo");
ie.include("bar");
assertEquals(2,ie.size());
assertThat("IncludeExclude.size", ie.size(), is(2));
assertEquals(false,ie.matches(""));
assertEquals(true,ie.matches("foo"));
assertEquals(true,ie.matches("bar"));
@ -86,7 +88,7 @@ public class IncludeExcludeTest
@Test
public void testEmptyRegex()
{
IncludeExclude<String> ie = new IncludeExclude<>(RegexSet.class,RegexSet.MATCHER);
IncludeExclude<String> ie = new IncludeExclude<>(RegexSet.class);
assertEquals(0,ie.size());
assertEquals(true,ie.matches("foo"));
@ -95,7 +97,7 @@ public class IncludeExcludeTest
@Test
public void testIncludeRegex()
{
IncludeExclude<String> ie = new IncludeExclude<>(RegexSet.class,RegexSet.MATCHER);
IncludeExclude<String> ie = new IncludeExclude<>(RegexSet.class);
ie.include("f..");
ie.include("b((ar)|(oo))");
@ -112,7 +114,7 @@ public class IncludeExcludeTest
@Test
public void testExcludeRegex()
{
IncludeExclude<String> ie = new IncludeExclude<>(RegexSet.class,RegexSet.MATCHER);
IncludeExclude<String> ie = new IncludeExclude<>(RegexSet.class);
ie.exclude("f..");
ie.exclude("b((ar)|(oo))");
@ -130,7 +132,7 @@ public class IncludeExcludeTest
@Test
public void testIncludeExcludeRegex()
{
IncludeExclude<String> ie = new IncludeExclude<>(RegexSet.class,RegexSet.MATCHER);
IncludeExclude<String> ie = new IncludeExclude<>(RegexSet.class);
ie.include(".*[aeiou].*");
ie.include("[AEIOU].*");
ie.exclude("f..");
@ -146,8 +148,5 @@ public class IncludeExcludeTest
assertEquals(true,ie.matches("foobar"));
assertEquals(true,ie.matches("Ant"));
}
}

View File

@ -32,12 +32,15 @@ import java.security.KeyStore;
import javax.net.ssl.SSLEngine;
import org.eclipse.jetty.toolchain.test.JDK;
import org.eclipse.jetty.toolchain.test.OS;
import org.eclipse.jetty.util.component.AbstractLifeCycle;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.StdErrLog;
import org.eclipse.jetty.util.resource.Resource;
import org.hamcrest.Matchers;
import org.junit.Assert;
import org.junit.Assume;
import org.junit.Before;
import org.junit.Test;
@ -207,6 +210,8 @@ public class SslContextFactoryTest
public void testSetIncludeCipherSuitesRegex() throws Exception
{
cf.setIncludeCipherSuites(".*ECDHE.*",".*WIBBLE.*");
Assume.assumeFalse(JDK.IS_8);
cf.start();
SSLEngine sslEngine = cf.newSSLEngine();
String[] enabledCipherSuites = sslEngine.getEnabledCipherSuites();