The standard JVM {@link ByteBuffer} can exist in two modes: In fill mode the valid
+ * data is between 0 and pos; In flush mode the valid data is between the pos and the limit.
+ * The various ByteBuffer methods assume a mode and some of them will switch or enforce a mode:
+ * Allocate and clear set fill mode; flip and compact switch modes; read and write assume fill
+ * and flush modes. This duality can result in confusing code such as:
+ *
+ * Which looks as if it should write no data, but in fact writes the buffer worth of garbage.
+ *
*
- * ByteBuffers can be considered in one of two modes: Flush mode where valid content is contained between
- * position and limit which is consumed by advancing the position; and Fill mode where empty space is between
- * the position and limit, which is filled by advancing the position. In fill mode, there may be valid data
- * in the buffer before the position and the start of this data is given by the return value of {@link #flipToFill(ByteBuffer)}
+ * The BufferUtil class provides a set of utilities that operate on the convention that ByteBuffers
+ * will always be left, passed in an API or returned from a method in the flush mode - ie with
+ * valid data between the pos and limit. This convention is adopted so as to avoid confusion as to
+ * what state a buffer is in and to avoid excessive copying of data that can result with the usage
+ * of compress.
*
- * A typical pattern for using the buffers in this style is:
- *
+ * Thus this class provides alternate implementations of {@link #allocate(int)},
+ * {@link #allocateDirect(int)} and {@link #clear(ByteBuffer)} that leave the buffer
+ * in flush mode. Thus the following tests will pass:
If the BufferUtil methods {@link #fill(ByteBuffer, byte[], int, int)},
+ * {@link #append(ByteBuffer, byte[], int, int)} or {@link #put(ByteBuffer, ByteBuffer)} are used,
+ * then the caller does not need to explicitly switch the buffer to fill mode.
+ * If the caller wishes to use other ByteBuffer bases libraries to fill a buffer,
+ * then they can use explicit calls of #flipToFill(ByteBuffer) and #flipToFlush(ByteBuffer, int)
+ * to change modes. Note because this convention attempts to avoid the copies of compact, the position
+ * is not set to zero on each fill cycle and so its value must be remembered:
+ *
+ * The flipToFill method will effectively clear the buffer if it is emtpy and will compact the buffer if there is no space.
+ *
*/
public class BufferUtil
{
+ static final int TEMP_BUFFER_SIZE = 512;
static final byte SPACE = 0x20;
static final byte MINUS = '-';
static final byte[] DIGIT =
- { (byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5', (byte)'6', (byte)'7', (byte)'8', (byte)'9', (byte)'A', (byte)'B', (byte)'C', (byte)'D',
- (byte)'E', (byte)'F' };
+ {(byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5', (byte)'6', (byte)'7', (byte)'8', (byte)'9', (byte)'A', (byte)'B', (byte)'C', (byte)'D',
+ (byte)'E', (byte)'F'};
public static final ByteBuffer EMPTY_BUFFER = ByteBuffer.wrap(new byte[0]);
@@ -73,7 +97,7 @@ public class BufferUtil
/** Allocate ByteBuffer in flush mode.
* The position and limit will both be zero, indicating that the buffer is
* empty and must be flipped before any data is put to it.
- * @param capacity
+ * @param capacity capacity of the allocated ByteBuffer
* @return Buffer
*/
public static ByteBuffer allocate(int capacity)
@@ -86,8 +110,8 @@ public class BufferUtil
/* ------------------------------------------------------------ */
/** Allocate ByteBuffer in flush mode.
* The position and limit will both be zero, indicating that the buffer is
- * empty and must be flipped before any data is put to it.
- * @param capacity
+ * empty and in flush mode.
+ * @param capacity capacity of the allocated ByteBuffer
* @return Buffer
*/
public static ByteBuffer allocateDirect(int capacity)
@@ -105,7 +129,7 @@ public class BufferUtil
*/
public static void clear(ByteBuffer buffer)
{
- if (buffer!=null)
+ if (buffer != null)
{
buffer.position(0);
buffer.limit(0);
@@ -119,7 +143,7 @@ public class BufferUtil
*/
public static void clearToFill(ByteBuffer buffer)
{
- if (buffer!=null)
+ if (buffer != null)
{
buffer.position(0);
buffer.limit(buffer.capacity());
@@ -142,17 +166,17 @@ public class BufferUtil
*/
public static int flipToFill(ByteBuffer buffer)
{
- int position=buffer.position();
- int limit=buffer.limit();
- if (position==limit)
+ int position = buffer.position();
+ int limit = buffer.limit();
+ if (position == limit)
{
buffer.position(0);
buffer.limit(buffer.capacity());
return 0;
}
- int capacity=buffer.capacity();
- if (limit==capacity)
+ int capacity = buffer.capacity();
+ if (limit == capacity)
{
buffer.compact();
return 0;
@@ -170,11 +194,11 @@ public class BufferUtil
* the position is set to the passed position.
*
* This method is used as a replacement of {@link Buffer#flip()}.
- * @param buffer the buffer to be flipped
+ * @param buffer the buffer to be flipped
* @param position The position of valid data to flip to. This should
* be the return value of the previous call to {@link #flipToFill(ByteBuffer)}
*/
- public static void flipToFlush(ByteBuffer buffer,int position)
+ public static void flipToFlush(ByteBuffer buffer, int position)
{
buffer.limit(buffer.position());
buffer.position(position);
@@ -192,7 +216,7 @@ public class BufferUtil
if (buffer.hasArray())
{
byte[] array = buffer.array();
- System.arraycopy(array,buffer.arrayOffset()+buffer.position(),to,0,to.length);
+ System.arraycopy(array, buffer.arrayOffset() + buffer.position(), to, 0, to.length);
}
else
buffer.slice().get(to);
@@ -206,7 +230,7 @@ public class BufferUtil
*/
public static boolean isEmpty(ByteBuffer buf)
{
- return buf==null || buf.remaining()==0;
+ return buf == null || buf.remaining() == 0;
}
/* ------------------------------------------------------------ */
@@ -216,7 +240,7 @@ public class BufferUtil
*/
public static boolean hasContent(ByteBuffer buf)
{
- return buf!=null && buf.remaining()>0;
+ return buf != null && buf.remaining() > 0;
}
/* ------------------------------------------------------------ */
@@ -226,7 +250,7 @@ public class BufferUtil
*/
public static boolean isFull(ByteBuffer buf)
{
- return buf!=null && buf.limit()==buf.capacity();
+ return buf != null && buf.limit() == buf.capacity();
}
/* ------------------------------------------------------------ */
@@ -236,70 +260,70 @@ public class BufferUtil
*/
public static int length(ByteBuffer buffer)
{
- return buffer==null?0:buffer.remaining();
+ return buffer == null ? 0 : buffer.remaining();
}
/* ------------------------------------------------------------ */
/** Get the space from the limit to the capacity
- * @param buffer
+ * @param buffer the buffer to get the space from
* @return space
*/
public static int space(ByteBuffer buffer)
{
- if (buffer==null)
+ if (buffer == null)
return 0;
- return buffer.capacity()-buffer.limit();
+ return buffer.capacity() - buffer.limit();
}
/* ------------------------------------------------------------ */
/** Compact the buffer
- * @param buffer
+ * @param buffer the buffer to compact
* @return true if the compact made a full buffer have space
*/
public static boolean compact(ByteBuffer buffer)
{
- boolean full=buffer.limit()==buffer.capacity();
+ boolean full = buffer.limit() == buffer.capacity();
buffer.compact().flip();
- return full && buffer.limit()0)
+ int remaining = from.remaining();
+ if (remaining > 0)
{
- if (remaining<=to.remaining())
+ if (remaining <= to.remaining())
{
to.put(from);
- put=remaining;
+ put = remaining;
from.position(0);
from.limit(0);
}
else if (from.hasArray())
{
- put=to.remaining();
- to.put(from.array(),from.arrayOffset()+from.position(),put);
- from.position(from.position()+put);
+ put = to.remaining();
+ to.put(from.array(), from.arrayOffset() + from.position(), put);
+ from.position(from.position() + put);
}
else
{
- put=to.remaining();
- ByteBuffer slice=from.slice();
+ put = to.remaining();
+ ByteBuffer slice = from.slice();
slice.limit(put);
to.put(slice);
- from.position(from.position()+put);
+ from.position(from.position() + put);
}
}
else
- put=0;
+ put = 0;
return put;
}
@@ -308,76 +332,87 @@ public class BufferUtil
/**
* Put data from one buffer into another, avoiding over/under flows
* @param from Buffer to take bytes from in flush mode
- * @param to Buffer to put bytes to in flush mode. The buffer is flipToFill before the put and flipToFlush after.
+ * @param to Buffer to put bytes to in flush mode. The buffer is flipToFill before the put and flipToFlush after.
* @return number of bytes moved
*/
public static int flipPutFlip(ByteBuffer from, ByteBuffer to)
{
- int pos= flipToFill(to);
+ int pos = flipToFill(to);
try
{
- return put(from,to);
+ return put(from, to);
}
finally
{
- flipToFlush(to,pos);
+ flipToFlush(to, pos);
+ }
+ }
+
+ /* ------------------------------------------------------------ */
+ /** Append bytes to a buffer.
+ *
+ */
+ public static void append(ByteBuffer to, byte[] b, int off, int len) throws BufferOverflowException
+ {
+ int pos = flipToFill(to);
+ try
+ {
+ to.put(b, off, len);
+ }
+ finally
+ {
+ flipToFlush(to, pos);
+ }
+ }
+
+ /* ------------------------------------------------------------ */
+ /** Appends a byte to a buffer
+ */
+ public static void append(ByteBuffer to, byte b)
+ {
+ int pos = flipToFill(to);
+ try
+ {
+ to.put(b);
+ }
+ finally
+ {
+ flipToFlush(to, pos);
}
}
/* ------------------------------------------------------------ */
/**
+ * Like append, but does not throw {@link BufferOverflowException}
*/
- public static void append(ByteBuffer to, byte[] b,int off,int len) throws BufferOverflowException
+ public static int fill(ByteBuffer to, byte[] b, int off, int len)
{
- int pos= flipToFill(to);
+ int pos = flipToFill(to);
try
{
- to.put(b,off,len);
- }
- finally
- {
- flipToFlush(to,pos);
- }
- }
-
- /* ------------------------------------------------------------ */
- /** Like append, but does not throw {@link BufferOverflowException}
- */
- public static int fill(ByteBuffer to, byte[] b,int off,int len)
- {
- int pos= flipToFill(to);
- try
- {
- int remaining=to.remaining();
- int take=remaining0 && buffer.hasRemaining())
- needed=needed-channel.read(buffer);
+ while (needed>0 && buffer.hasRemaining())
+ needed=needed-channel.read(buffer);
+ }
}
/* ------------------------------------------------------------ */
@@ -385,10 +420,10 @@ public class BufferUtil
{
ByteBuffer tmp = allocate(8192);
- while (needed>0 && buffer.hasRemaining())
+ while (needed > 0 && buffer.hasRemaining())
{
- int l = is.read(tmp.array(),0,8192);
- if (l<0)
+ int l = is.read(tmp.array(), 0, 8192);
+ if (l < 0)
break;
tmp.position(0);
tmp.limit(l);
@@ -400,12 +435,15 @@ public class BufferUtil
public static void writeTo(ByteBuffer buffer, OutputStream out) throws IOException
{
if (buffer.hasArray())
- out.write(buffer.array(),buffer.arrayOffset()+buffer.position(),buffer.remaining());
+ out.write(buffer.array(), buffer.arrayOffset() + buffer.position(), buffer.remaining());
else
{
- // TODO this is horribly inefficient
- for (int i=buffer.position();i=' ' && c<=127)
+ char c = (char)buffer.get(i);
+ if (c >= ' ' && c <= 127)
buf.append(c);
- else if (c=='\r'||c=='\n')
+ else if (c == '\r' || c == '\n')
buf.append('|');
else
buf.append('\ufffd');
- if (i==16&&buffer.position()>32)
+ if (i == 16 && buffer.position() > 32)
{
buf.append("...");
- i=buffer.position()-16;
+ i = buffer.position() - 16;
}
}
buf.append("<<<");
- for (int i=buffer.position();i=' ' && c<=127)
+ char c = (char)buffer.get(i);
+ if (c >= ' ' && c <= 127)
buf.append(c);
- else if (c=='\r'||c=='\n')
+ else if (c == '\r' || c == '\n')
buf.append('|');
else
buf.append('\ufffd');
- if (i==buffer.position()+16&&buffer.limit()>buffer.position()+32)
+ if (i == buffer.position() + 16 && buffer.limit() > buffer.position() + 32)
{
buf.append("...");
- i=buffer.limit()-16;
+ i = buffer.limit() - 16;
}
}
buf.append(">>>");
- int limit=buffer.limit();
+ int limit = buffer.limit();
buffer.limit(buffer.capacity());
- for (int i=limit;i=' ' && c<=127)
+ char c = (char)buffer.get(i);
+ if (c >= ' ' && c <= 127)
buf.append(c);
- else if (c=='\r'||c=='\n')
+ else if (c == '\r' || c == '\n')
buf.append('|');
else
buf.append('\ufffd');
- if (i==limit+16&&buffer.capacity()>limit+32)
+ if (i == limit + 16 && buffer.capacity() > limit + 32)
{
buf.append("...");
- i=buffer.capacity()-16;
+ i = buffer.capacity() - 16;
}
}
buffer.limit(limit);
@@ -866,14 +904,14 @@ public class BufferUtil
private final static int[] decDivisors =
- { 1000000000, 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10, 1 };
+ {1000000000, 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10, 1};
private final static int[] hexDivisors =
- { 0x10000000, 0x1000000, 0x100000, 0x10000, 0x1000, 0x100, 0x10, 0x1 };
+ {0x10000000, 0x1000000, 0x100000, 0x10000, 0x1000, 0x100, 0x10, 0x1};
private final static long[] decDivisorsL =
- { 1000000000000000000L, 100000000000000000L, 10000000000000000L, 1000000000000000L, 100000000000000L, 10000000000000L, 1000000000000L, 100000000000L,
- 10000000000L, 1000000000L, 100000000L, 10000000L, 1000000L, 100000L, 10000L, 1000L, 100L, 10L, 1L };
+ {1000000000000000000L, 100000000000000000L, 10000000000000000L, 1000000000000000L, 100000000000000L, 10000000000000L, 1000000000000L, 100000000000L,
+ 10000000000L, 1000000000L, 100000000L, 10000000L, 1000000L, 100000L, 10000L, 1000L, 100L, 10L, 1L};
public static void putCRLF(ByteBuffer buffer)
{
diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/ManagedAttribute.java b/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/ManagedAttribute.java
index cc12b3c0c35..df1cdd5d763 100644
--- a/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/ManagedAttribute.java
+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/ManagedAttribute.java
@@ -36,6 +36,16 @@ import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
+/**
+ * The @ManagedAttribute annotation is used to indicate that a given method
+ * exposes a JMX attribute. This annotation is placed always on the reader
+ * method of a given attribute. Unless it is marked as read-only in the
+ * configuration of the annotation a corresponding setter is looked for
+ * following normal naming conventions. For example if this annotation is
+ * on a method called getFoo() then a method called setFoo() would be looked
+ * for and if found wired automatically into the jmx attribute.
+ *
+ */
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Target( { ElementType.METHOD } )
diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/ManagedObject.java b/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/ManagedObject.java
index a323dc4cb2a..b51f2afe3c9 100644
--- a/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/ManagedObject.java
+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/ManagedObject.java
@@ -24,6 +24,14 @@ import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
+/**
+ * The @ManagedObject annotation is used on a class at the top level to
+ * indicate that it should be exposed as an mbean. It has only one attribute
+ * to it which is used as the description of the MBean. Should multiple
+ * @ManagedObject annotations be found in the chain of influence then the
+ * first description is used.
+ *
+ */
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Target( { ElementType.TYPE } )
diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/ManagedOperation.java b/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/ManagedOperation.java
index e65e0ba19e0..b9ff0257b60 100644
--- a/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/ManagedOperation.java
+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/ManagedOperation.java
@@ -36,6 +36,11 @@ import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
+/**
+ * The @ManagedOperation annotation is used to indicate that a given method
+ * should be considered a JMX operation.
+ *
+ */
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Target( { ElementType.METHOD } )
diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/Name.java b/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/Name.java
index cfd631abd2f..5d7f1b74328 100644
--- a/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/Name.java
+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/annotation/Name.java
@@ -24,11 +24,28 @@ import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
+/**
+ * This annotation is used to describe variables in method
+ * signatures so that when rendered into tools like JConsole
+ * it is clear what the parameters are. For example:
+ *
+ * public void doodle(@Name(value="doodle", description="A description of the argument") String doodle)
+ *
+ */
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Target( { ElementType.PARAMETER } )
public @interface Name
{
+ /**
+ * the name of the parameter
+ * @return
+ */
String value();
+
+ /**
+ * the description of the parameter
+ * @return
+ */
String description() default "";
}
diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/component/FileDestroyable.java b/jetty-util/src/main/java/org/eclipse/jetty/util/component/FileDestroyable.java
index e38eb8b35d5..fdc9f9834f3 100644
--- a/jetty-util/src/main/java/org/eclipse/jetty/util/component/FileDestroyable.java
+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/component/FileDestroyable.java
@@ -50,7 +50,10 @@ public class FileDestroyable implements Destroyable
public void addFile(String file) throws IOException
{
- _files.add(Resource.newResource(file).getFile());
+ try(Resource r = Resource.newResource(file);)
+ {
+ _files.add(r.getFile());
+ }
}
public void addFile(File file)
@@ -65,7 +68,10 @@ public class FileDestroyable implements Destroyable
public void removeFile(String file) throws IOException
{
- _files.remove(Resource.newResource(file).getFile());
+ try(Resource r = Resource.newResource(file);)
+ {
+ _files.remove(r.getFile());
+ }
}
public void removeFile(File file)
@@ -73,6 +79,7 @@ public class FileDestroyable implements Destroyable
_files.remove(file);
}
+ @Override
public void destroy()
{
for (File file : _files)
diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/FileResource.java b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/FileResource.java
index 030f02a314c..3fc1ef7d8d7 100644
--- a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/FileResource.java
+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/FileResource.java
@@ -20,10 +20,8 @@ package org.eclipse.jetty.util.resource;
import java.io.File;
import java.io.FileInputStream;
-import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
-import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
@@ -50,25 +48,24 @@ import org.eclipse.jetty.util.log.Logger;
*
*
*/
-public class FileResource extends URLResource
+public class FileResource extends Resource
{
private static final Logger LOG = Log.getLogger(FileResource.class);
/* ------------------------------------------------------------ */
- private File _file;
- private transient URL _alias=null;
- private transient boolean _aliasChecked=false;
+ private final File _file;
+ private final String _uri;
+ private final URL _alias;
/* -------------------------------------------------------- */
public FileResource(URL url)
throws IOException, URISyntaxException
{
- super(url,null);
-
+ File file;
try
{
// Try standard API to convert URL to file.
- _file =new File(new URI(url.toString()));
+ file =new File(url.toURI());
}
catch (URISyntaxException e)
{
@@ -76,48 +73,86 @@ public class FileResource extends URLResource
}
catch (Exception e)
{
+ if (!url.toString().startsWith("file:"))
+ throw new IllegalArgumentException("!file:");
+
LOG.ignore(e);
try
{
- // Assume that File.toURL produced unencoded chars. So try
- // encoding them.
+ // Assume that File.toURL produced unencoded chars. So try encoding them.
String file_url="file:"+URIUtil.encodePath(url.toString().substring(5));
URI uri = new URI(file_url);
if (uri.getAuthority()==null)
- _file = new File(uri);
+ file = new File(uri);
else
- _file = new File("//"+uri.getAuthority()+URIUtil.decodePath(url.getFile()));
+ file = new File("//"+uri.getAuthority()+URIUtil.decodePath(url.getFile()));
}
catch (Exception e2)
{
LOG.ignore(e2);
-
// Still can't get the file. Doh! try good old hack!
- checkConnection();
- Permission perm = _connection.getPermission();
- _file = new File(perm==null?url.getFile():perm.getName());
+ URLConnection connection=url.openConnection();
+ Permission perm = connection.getPermission();
+ file = new File(perm==null?url.getFile():perm.getName());
}
}
- if (_file.isDirectory())
- {
- if (!_urlString.endsWith("/"))
- _urlString=_urlString+"/";
- }
- else
- {
- if (_urlString.endsWith("/"))
- _urlString=_urlString.substring(0,_urlString.length()-1);
- }
-
+
+ _file=file;
+ _uri=normalizeURI(_file,url.toURI());
+ _alias=checkAlias(_file);
}
/* -------------------------------------------------------- */
- FileResource(URL url, URLConnection connection, File file)
+ public FileResource(URI uri)
{
- super(url,connection);
+ File file=new File(uri);
_file=file;
- if (_file.isDirectory() && !_urlString.endsWith("/"))
- _urlString=_urlString+"/";
+ _uri=normalizeURI(_file,uri);
+ _alias=checkAlias(_file);
+ }
+
+ /* -------------------------------------------------------- */
+ FileResource(File file)
+ {
+ _file=file;
+ _uri=normalizeURI(_file,_file.toURI());
+ _alias=checkAlias(_file);
+ }
+
+ /* -------------------------------------------------------- */
+ private static String normalizeURI(File file, URI uri)
+ {
+ String u =uri.toASCIIString();
+ if (file.isDirectory())
+ {
+ if(!u.endsWith("/"))
+ u+="/";
+ }
+ else if (file.exists() && u.endsWith("/"))
+ u=u.substring(0,u.length()-1);
+ return u;
+ }
+
+ /* -------------------------------------------------------- */
+ private static URL checkAlias(File file)
+ {
+ try
+ {
+ String abs=file.getAbsolutePath();
+ String can=file.getCanonicalPath();
+
+ if (!abs.equals(can))
+ {
+ LOG.debug("ALIAS abs={} can={}",abs,can);
+ return new File(can).toURI().toURL();
+ }
+ }
+ catch(IOException e)
+ {
+ LOG.warn(e);
+ }
+
+ return null;
}
/* -------------------------------------------------------- */
@@ -125,45 +160,35 @@ public class FileResource extends URLResource
public Resource addPath(String path)
throws IOException,MalformedURLException
{
- URLResource r=null;
- String url=null;
-
path = org.eclipse.jetty.util.URIUtil.canonicalPath(path);
-
+
+ if (path==null)
+ throw new MalformedURLException();
+
if ("/".equals(path))
return this;
- else if (!isDirectory())
- {
- r=(FileResource)super.addPath(path);
- url=r._urlString;
- }
- else
- {
- if (path==null)
- throw new MalformedURLException();
-
- // treat all paths being added as relative
- String rel=path;
- if (path.startsWith("/"))
- rel = path.substring(1);
-
- url=URIUtil.addPaths(_urlString,URIUtil.encodePath(rel));
- r=(URLResource)Resource.newResource(url);
- }
- String encoded=URIUtil.encodePath(path);
- int expected=r.toString().length()-encoded.length();
- int index = r._urlString.lastIndexOf(encoded, expected);
+ path=URIUtil.encodePath(path);
- if (expected!=index && ((expected-1)!=index || path.endsWith("/") || !r.isDirectory()))
+ URI uri;
+ try
{
- if (!(r instanceof BadResource))
+ if (_file.isDirectory())
{
- ((FileResource)r)._alias=new URL(url);
- ((FileResource)r)._aliasChecked=true;
+ // treat all paths being added as relative
+ uri=new URI(URIUtil.addPaths(_uri,path));
}
- }
- return r;
+ else
+ {
+ uri=new URI(_uri+path);
+ }
+ }
+ catch(final URISyntaxException e)
+ {
+ throw new MalformedURLException(){{initCause(e);}};
+ }
+
+ return new FileResource(uri);
}
@@ -171,30 +196,6 @@ public class FileResource extends URLResource
@Override
public URL getAlias()
{
- if (!_aliasChecked)
- {
- try
- {
- String abs=_file.getAbsolutePath();
- String can=_file.getCanonicalPath();
-
- if (abs.length()!=can.length() || !abs.equals(can))
- _alias=Resource.toURL(new File(can));
-
- _aliasChecked=true;
-
- if (_alias!=null && LOG.isDebugEnabled())
- {
- LOG.debug("ALIAS abs="+abs);
- LOG.debug("ALIAS can="+can);
- }
- }
- catch(Exception e)
- {
- LOG.warn(Log.EXCEPTION,e);
- return getURL();
- }
- }
return _alias;
}
@@ -220,12 +221,12 @@ public class FileResource extends URLResource
/* -------------------------------------------------------- */
/**
- * Returns true if the respresenetd resource is a container/directory.
+ * Returns true if the resource is a container/directory.
*/
@Override
public boolean isDirectory()
{
- return _file.isDirectory();
+ return _file.exists() && _file.isDirectory() || _uri.endsWith("/");
}
/* --------------------------------------------------------- */
@@ -320,18 +321,6 @@ public class FileResource extends URLResource
}
return list;
}
-
- /* ------------------------------------------------------------ */
- /** Encode according to this resource type.
- * File URIs are encoded.
- * @param uri URI to encode.
- * @return The uri unchanged.
- */
- @Override
- public String encode(String uri)
- {
- return uri;
- }
/* ------------------------------------------------------------ */
/**
@@ -377,4 +366,35 @@ public class FileResource extends URLResource
IO.copy(getFile(),destination);
}
}
+
+ @Override
+ public boolean isContainedIn(Resource r) throws MalformedURLException
+ {
+ return false;
+ }
+
+ @Override
+ public void close()
+ {
+ }
+
+ @Override
+ public URL getURL()
+ {
+ try
+ {
+ return _file.toURI().toURL();
+ }
+ catch (MalformedURLException e)
+ {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ @Override
+ public String toString()
+ {
+ return _uri;
+ }
+
}
diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/JarFileResource.java b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/JarFileResource.java
index 79a5d8fe5ee..a4004b8b4f0 100644
--- a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/JarFileResource.java
+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/JarFileResource.java
@@ -60,7 +60,7 @@ class JarFileResource extends JarResource
/* ------------------------------------------------------------ */
@Override
- public synchronized void release()
+ public synchronized void close()
{
_list=null;
_entry=null;
@@ -83,7 +83,7 @@ class JarFileResource extends JarResource
}
}
_jarFile=null;
- super.release();
+ super.close();
}
/* ------------------------------------------------------------ */
@@ -374,18 +374,6 @@ class JarFileResource extends JarResource
return -1;
}
-
- /* ------------------------------------------------------------ */
- /** Encode according to this resource type.
- * File URIs are not encoded.
- * @param uri URI to encode.
- * @return The uri unchanged.
- */
- @Override
- public String encode(String uri)
- {
- return uri;
- }
/**
diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/JarResource.java b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/JarResource.java
index a221d539cab..fe9dbb44e27 100644
--- a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/JarResource.java
+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/JarResource.java
@@ -55,10 +55,10 @@ public class JarResource extends URLResource
/* ------------------------------------------------------------ */
@Override
- public synchronized void release()
+ public synchronized void close()
{
_jarConnection=null;
- super.release();
+ super.close();
}
/* ------------------------------------------------------------ */
diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/Resource.java b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/Resource.java
index f80e5ab5f54..683156672f1 100644
--- a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/Resource.java
+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/Resource.java
@@ -18,6 +18,7 @@
package org.eclipse.jetty.util.resource;
+import java.io.Closeable;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
@@ -26,7 +27,6 @@ import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
-import java.net.URLConnection;
import java.nio.channels.ReadableByteChannel;
import java.text.DateFormat;
import java.util.Arrays;
@@ -45,7 +45,7 @@ import org.eclipse.jetty.util.log.Logger;
/**
* Abstract resource class.
*/
-public abstract class Resource implements ResourceFactory
+public abstract class Resource implements ResourceFactory, Closeable
{
private static final Logger LOG = Log.getLogger(Resource.class);
public static boolean __defaultUseCaches = true;
@@ -149,7 +149,7 @@ public abstract class Resource implements ResourceFactory
* @param useCaches controls URLConnection caching
* @return A Resource object.
*/
- public static Resource newResource (String resource, boolean useCaches)
+ public static Resource newResource(String resource, boolean useCaches)
throws MalformedURLException, IOException
{
URL url=null;
@@ -171,11 +171,7 @@ public abstract class Resource implements ResourceFactory
resource=resource.substring(2);
File file=new File(resource).getCanonicalFile();
- url=Resource.toURL(file);
-
- URLConnection connection=url.openConnection();
- connection.setUseCaches(useCaches);
- return new FileResource(url,connection,file);
+ return new FileResource(file);
}
catch(Exception e2)
{
@@ -194,15 +190,9 @@ public abstract class Resource implements ResourceFactory
}
/* ------------------------------------------------------------ */
- public static Resource newResource (File file)
- throws MalformedURLException, IOException
+ public static Resource newResource(File file)
{
- file = file.getCanonicalFile();
- URL url = Resource.toURL(file);
-
- URLConnection connection = url.openConnection();
- FileResource fileResource = new FileResource(url, connection, file);
- return fileResource;
+ return new FileResource(file);
}
/* ------------------------------------------------------------ */
@@ -300,7 +290,7 @@ public abstract class Resource implements ResourceFactory
@Override
protected void finalize()
{
- release();
+ close();
}
/* ------------------------------------------------------------ */
@@ -309,9 +299,18 @@ public abstract class Resource implements ResourceFactory
/* ------------------------------------------------------------ */
/** Release any temporary resources held by the resource.
+ * @deprecated use {@link #close()}
*/
- public abstract void release();
-
+ public final void release()
+ {
+ close();
+ }
+
+ /* ------------------------------------------------------------ */
+ /** Release any temporary resources held by the resource.
+ */
+ @Override
+ public abstract void close();
/* ------------------------------------------------------------ */
/**
@@ -420,19 +419,19 @@ public abstract class Resource implements ResourceFactory
/**
* Returns the resource contained inside the current resource with the
* given name.
- * @param path The path segment to add, which should be encoded by the
- * encode method.
+ * @param path The path segment to add, which is not encoded
*/
public abstract Resource addPath(String path)
throws IOException,MalformedURLException;
/* ------------------------------------------------------------ */
- /** Get a resource from withing this resource.
+ /** Get a resource from within this resource.
*
* This method is essentially an alias for {@link #addPath(String)}, but without checked exceptions.
* This method satisfied the {@link ResourceFactory} interface.
* @see org.eclipse.jetty.util.resource.ResourceFactory#getResource(java.lang.String)
*/
+ @Override
public Resource getResource(String path)
{
try
@@ -447,14 +446,12 @@ public abstract class Resource implements ResourceFactory
}
/* ------------------------------------------------------------ */
- /** Encode according to this resource type.
- * The default implementation calls URI.encodePath(uri)
- * @param uri
- * @return String encoded for this resource type.
+ /**
+ * @deprecated
*/
public String encode(String uri)
{
- return URIUtil.encodePath(uri);
+ return null;
}
/* ------------------------------------------------------------ */
diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/ResourceCollection.java b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/ResourceCollection.java
index 36fd49b4546..451a1514b27 100644
--- a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/ResourceCollection.java
+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/ResourceCollection.java
@@ -21,7 +21,6 @@ package org.eclipse.jetty.util.resource;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
-import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.channels.ReadableByteChannel;
@@ -32,7 +31,6 @@ import java.util.List;
import java.util.StringTokenizer;
import org.eclipse.jetty.util.URIUtil;
-import org.eclipse.jetty.util.component.AbstractLifeCycle;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
@@ -228,12 +226,15 @@ public class ResourceCollection extends Resource
Resource r = _resources[i].addPath(path);
if (r.exists() && r.isDirectory())
{
+ if (resources==null)
+ resources = new ArrayList();
+
if (resource!=null)
{
- resources = new ArrayList();
resources.add(resource);
resource=null;
}
+
resources.add(r);
}
}
@@ -443,13 +444,13 @@ public class ResourceCollection extends Resource
/* ------------------------------------------------------------ */
@Override
- public void release()
+ public void close()
{
if(_resources==null)
throw new IllegalStateException("*resources* not set.");
for(Resource r : _resources)
- r.release();
+ r.close();
}
/* ------------------------------------------------------------ */
diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/URLResource.java b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/URLResource.java
index 2431b880088..4bb59a4e830 100644
--- a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/URLResource.java
+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/URLResource.java
@@ -81,7 +81,7 @@ public class URLResource extends Resource
/** Release any resources held by the resource.
*/
@Override
- public synchronized void release()
+ public synchronized void close()
{
if (_in!=null)
{
diff --git a/jetty-util/src/test/java/org/eclipse/jetty/util/BufferUtilTest.java b/jetty-util/src/test/java/org/eclipse/jetty/util/BufferUtilTest.java
index 47fb5515dac..886474e5b42 100644
--- a/jetty-util/src/test/java/org/eclipse/jetty/util/BufferUtilTest.java
+++ b/jetty-util/src/test/java/org/eclipse/jetty/util/BufferUtilTest.java
@@ -19,16 +19,24 @@
package org.eclipse.jetty.util;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
import java.nio.BufferOverflowException;
import java.nio.ByteBuffer;
import java.util.Arrays;
+import java.util.Random;
+import org.eclipse.jetty.util.log.Log;
+import org.eclipse.jetty.util.log.Logger;
import org.junit.Assert;
+import org.junit.Ignore;
import org.junit.Test;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
public class BufferUtilTest
{
@Test
@@ -225,4 +233,71 @@ public class BufferUtilTest
Assert.assertEquals("Count of bytes",length,count);
}
+
+ private static final Logger LOG = Log.getLogger(BufferUtilTest.class);
+
+ @Test
+ @Ignore("Very simple microbenchmark to compare different writeTo implementations. Only for development thus " +
+ "ignored.")
+ public void testWriteToMicrobenchmark() throws IOException
+ {
+ int capacity = 1024 * 128;
+ int iterations = 100;
+ int testRuns = 10;
+ byte[] bytes = new byte[capacity];
+ new Random().nextBytes(bytes);
+ ByteBuffer buffer = BufferUtil.allocate(capacity);
+ BufferUtil.append(buffer, bytes, 0, capacity);
+ long startTest = System.nanoTime();
+ for (int i = 0; i < testRuns; i++)
+ {
+ long start = System.nanoTime();
+ for (int j = 0; j < iterations; j++)
+ {
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ long startRun = System.nanoTime();
+ BufferUtil.writeTo(buffer.asReadOnlyBuffer(), out);
+ long elapsedRun = System.nanoTime() - startRun;
+// LOG.warn("run elapsed={}ms", elapsedRun / 1000);
+ assertThat("Bytes in out equal bytes in buffer", Arrays.equals(bytes, out.toByteArray()), is(true));
+ }
+ long elapsed = System.nanoTime() - start;
+ LOG.warn("elapsed={}ms average={}ms", elapsed / 1000, elapsed/iterations/1000);
+ }
+ LOG.warn("overall average: {}ms", (System.nanoTime() - startTest) / testRuns / iterations / 1000);
+ }
+
+ @Test
+ public void testWriteToWithBufferThatDoesNotExposeArrayAndSmallContent() throws IOException
+ {
+ int capacity = BufferUtil.TEMP_BUFFER_SIZE/4;
+ testWriteToWithBufferThatDoesNotExposeArray(capacity);
+ }
+
+ @Test
+ public void testWriteToWithBufferThatDoesNotExposeArrayAndContentLengthMatchingTempBufferSize() throws IOException
+ {
+ int capacity = BufferUtil.TEMP_BUFFER_SIZE;
+ testWriteToWithBufferThatDoesNotExposeArray(capacity);
+ }
+
+ @Test
+ public void testWriteToWithBufferThatDoesNotExposeArrayAndContentSlightlyBiggerThanTwoTimesTempBufferSize()
+ throws
+ IOException
+ {
+ int capacity = BufferUtil.TEMP_BUFFER_SIZE*2+1024;
+ testWriteToWithBufferThatDoesNotExposeArray(capacity);
+ }
+
+ private void testWriteToWithBufferThatDoesNotExposeArray(int capacity) throws IOException
+ {
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ byte[] bytes = new byte[capacity];
+ new Random().nextBytes(bytes);
+ ByteBuffer buffer = BufferUtil.allocate(capacity);
+ BufferUtil.append(buffer, bytes, 0, capacity);
+ BufferUtil.writeTo(buffer.asReadOnlyBuffer(), out);
+ assertThat("Bytes in out equal bytes in buffer", Arrays.equals(bytes, out.toByteArray()), is(true));
+ }
}
diff --git a/jetty-util/src/test/java/org/eclipse/jetty/util/resource/ResourceAliasTest.java b/jetty-util/src/test/java/org/eclipse/jetty/util/resource/ResourceAliasTest.java
new file mode 100644
index 00000000000..546d80a5c3a
--- /dev/null
+++ b/jetty-util/src/test/java/org/eclipse/jetty/util/resource/ResourceAliasTest.java
@@ -0,0 +1,118 @@
+//
+// ========================================================================
+// Copyright (c) 1995-2013 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.resource;
+
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertNotNull;
+import static junit.framework.Assert.assertNull;
+import static junit.framework.Assert.assertTrue;
+
+import java.io.File;
+import java.net.MalformedURLException;
+import java.net.URISyntaxException;
+
+import junit.framework.Assert;
+
+import org.eclipse.jetty.toolchain.test.FS;
+import org.eclipse.jetty.toolchain.test.MavenTestingUtils;
+import org.eclipse.jetty.toolchain.test.TestingDir;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+
+public class ResourceAliasTest
+{
+ static File __dir;
+
+ @BeforeClass
+ public static void beforeClass()
+ {
+ __dir=MavenTestingUtils.getTargetTestingDir("RAT");
+ }
+
+ @Before
+ public void before()
+ {
+ FS.ensureDirExists(__dir);
+ FS.ensureEmpty(__dir);
+ }
+
+
+ /* ------------------------------------------------------------ */
+ @Test
+ public void testNullCharEndingFilename() throws Exception
+ {
+ File file=new File(__dir,"test.txt");
+ assertFalse(file.exists());
+ file.createNewFile();
+ assertTrue(file.exists());
+
+ File file0=new File(__dir,"test.txt\0");
+ if (!file0.exists())
+ return; // this file system does not suffer this problem
+
+ assertTrue(file0.exists()); // This is an alias!
+
+ Resource dir = Resource.newResource(__dir);
+
+ // Test not alias paths
+ Resource resource = Resource.newResource(file);
+ assertTrue(resource.exists());
+ assertNull(resource.getAlias());
+ resource = Resource.newResource(file.getAbsoluteFile());
+ assertTrue(resource.exists());
+ assertNull(resource.getAlias());
+ resource = Resource.newResource(file.toURI());
+ assertTrue(resource.exists());
+ assertNull(resource.getAlias());
+ resource = Resource.newResource(file.toURI().toString());
+ assertTrue(resource.exists());
+ assertNull(resource.getAlias());
+ resource = dir.addPath("test.txt");
+ assertTrue(resource.exists());
+ assertNull(resource.getAlias());
+
+
+ // Test alias paths
+ resource = Resource.newResource(file0);
+ assertTrue(resource.exists());
+ assertNotNull(resource.getAlias());
+ resource = Resource.newResource(file0.getAbsoluteFile());
+ assertTrue(resource.exists());
+ assertNotNull(resource.getAlias());
+ resource = Resource.newResource(file0.toURI());
+ assertTrue(resource.exists());
+ assertNotNull(resource.getAlias());
+ resource = Resource.newResource(file0.toURI().toString());
+ assertTrue(resource.exists());
+ assertNotNull(resource.getAlias());
+
+ try
+ {
+ resource = dir.addPath("test.txt\0");
+ assertTrue(resource.exists());
+ assertNotNull(resource.getAlias());
+ }
+ catch(MalformedURLException e)
+ {
+ assertTrue(true);
+ }
+ }
+}
diff --git a/jetty-util/src/test/java/org/eclipse/jetty/util/resource/ResourceTest.java b/jetty-util/src/test/java/org/eclipse/jetty/util/resource/ResourceTest.java
index 1c5889fd15b..c811daa7643 100644
--- a/jetty-util/src/test/java/org/eclipse/jetty/util/resource/ResourceTest.java
+++ b/jetty-util/src/test/java/org/eclipse/jetty/util/resource/ResourceTest.java
@@ -33,12 +33,8 @@ import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
-import java.util.TimeZone;
-import java.util.jar.JarFile;
import java.util.zip.ZipFile;
-import junit.framework.Assert;
-
import org.eclipse.jetty.toolchain.test.MavenTestingUtils;
import org.eclipse.jetty.toolchain.test.OS;
import org.eclipse.jetty.util.IO;
@@ -329,13 +325,13 @@ public class ResourceTest
{
String s = "jar:"+__userURL+"TestData/test.zip!/subdir/numbers";
-
- ZipFile zf = new ZipFile(MavenTestingUtils.getTestResourceFile("TestData/test.zip"));
-
- long last = zf.getEntry("subdir/numbers").getTime();
+ try(ZipFile zf = new ZipFile(MavenTestingUtils.getTestResourceFile("TestData/test.zip")))
+ {
+ long last = zf.getEntry("subdir/numbers").getTime();
- Resource r = Resource.newResource(s);
- assertEquals(last,r.lastModified());
+ Resource r = Resource.newResource(s);
+ assertEquals(last,r.lastModified());
+ }
}
/* ------------------------------------------------------------ */
@@ -367,6 +363,7 @@ public class ResourceTest
assertEquals(1, dest.getParentFile().listFiles().length);
FilenameFilter dotdotFilenameFilter = new FilenameFilter() {
+ @Override
public boolean accept(File directory, String name)
{
return name.equals("dotdot.txt");
@@ -376,6 +373,7 @@ public class ResourceTest
assertEquals(0, dest.getParentFile().listFiles(dotdotFilenameFilter).length);
FilenameFilter extractfileFilenameFilter = new FilenameFilter() {
+ @Override
public boolean accept(File directory, String name)
{
return name.equals("extract-filenotdir");
@@ -385,6 +383,7 @@ public class ResourceTest
assertEquals(0, dest.getParentFile().listFiles(extractfileFilenameFilter).length);
FilenameFilter currentDirectoryFilenameFilter = new FilenameFilter() {
+ @Override
public boolean accept(File directory, String name)
{
return name.equals("current.txt");
@@ -405,15 +404,14 @@ public class ResourceTest
{
final String classPathName="Resource.class";
- Resource resource=Resource.newClassPathResource(classPathName);
+ try(Resource resource=Resource.newClassPathResource(classPathName);)
+ {
+ // A class path cannot be a directory
+ assertFalse("Class path cannot be a directory.",resource.isDirectory());
- assertTrue(resource!=null);
-
- // A class path cannot be a directory
- assertFalse("Class path cannot be a directory.",resource.isDirectory());
-
- // A class path must exist
- assertTrue("Class path resource does not exist.",resource.exists());
+ // A class path must exist
+ assertTrue("Class path resource does not exist.",resource.exists());
+ }
}
/**
@@ -426,8 +424,6 @@ public class ResourceTest
Resource resource=Resource.newClassPathResource(classPathName);
- assertTrue(resource!=null);
-
// A class path cannot be a directory
assertFalse("Class path cannot be a directory.",resource.isDirectory());
@@ -445,9 +441,6 @@ public class ResourceTest
Resource resource=Resource.newClassPathResource(classPathName);
-
- assertTrue(resource!=null);
-
// A class path must be a directory
assertTrue("Class path must be a directory.",resource.isDirectory());
@@ -469,8 +462,6 @@ public class ResourceTest
// Will locate a resource in the class path
Resource resource=Resource.newClassPathResource(classPathName);
- assertTrue(resource!=null);
-
// A class path cannot be a directory
assertFalse("Class path must be a directory.",resource.isDirectory());
@@ -478,7 +469,6 @@ public class ResourceTest
File file=resource.getFile();
- assertTrue("File returned from class path should not be null.",file!=null);
assertEquals("File name from class path is not equal.",fileName,file.getName());
assertTrue("File returned from class path should be a file.",file.isFile());
diff --git a/jetty-webapp/src/main/java/org/eclipse/jetty/webapp/Descriptor.java b/jetty-webapp/src/main/java/org/eclipse/jetty/webapp/Descriptor.java
index 038230b4e11..dfaa5f70531 100644
--- a/jetty-webapp/src/main/java/org/eclipse/jetty/webapp/Descriptor.java
+++ b/jetty-webapp/src/main/java/org/eclipse/jetty/webapp/Descriptor.java
@@ -66,7 +66,7 @@ public abstract class Descriptor
}
finally
{
- _xml.release();
+ _xml.close();
}
}
}
diff --git a/jetty-webapp/src/test/java/org/eclipse/jetty/webapp/OrderingTest.java b/jetty-webapp/src/test/java/org/eclipse/jetty/webapp/OrderingTest.java
index 7c19ca0d23a..5e5eec3eca6 100644
--- a/jetty-webapp/src/test/java/org/eclipse/jetty/webapp/OrderingTest.java
+++ b/jetty-webapp/src/test/java/org/eclipse/jetty/webapp/OrderingTest.java
@@ -167,10 +167,10 @@ public class OrderingTest
}
/**
- * @see org.eclipse.jetty.util.resource.Resource#release()
+ * @see org.eclipse.jetty.util.resource.Resource#close()
*/
@Override
- public void release()
+ public void close()
{
}
diff --git a/jetty-webapp/src/test/java/org/eclipse/jetty/webapp/WebAppClassLoaderTest.java b/jetty-webapp/src/test/java/org/eclipse/jetty/webapp/WebAppClassLoaderTest.java
index f815f7c63e1..41c6413df09 100644
--- a/jetty-webapp/src/test/java/org/eclipse/jetty/webapp/WebAppClassLoaderTest.java
+++ b/jetty-webapp/src/test/java/org/eclipse/jetty/webapp/WebAppClassLoaderTest.java
@@ -60,7 +60,7 @@ public class WebAppClassLoaderTest
assertTrue(cantLoadClass("org.eclipse.jetty.webapp.Configuration"));
- Class clazzA = _loader.loadClass("org.acme.webapp.ClassInJarA");
+ Class clazzA = _loader.loadClass("org.acme.webapp.ClassInJarA");
assertTrue(clazzA.getField("FROM_PARENT")!=null);
}
diff --git a/jetty-websocket/websocket-server/src/main/java/org/eclipse/jetty/websocket/server/ServletWebSocketRequest.java b/jetty-websocket/websocket-server/src/main/java/org/eclipse/jetty/websocket/server/ServletWebSocketRequest.java
index 44094eed40e..e274c963ee2 100644
--- a/jetty-websocket/websocket-server/src/main/java/org/eclipse/jetty/websocket/server/ServletWebSocketRequest.java
+++ b/jetty-websocket/websocket-server/src/main/java/org/eclipse/jetty/websocket/server/ServletWebSocketRequest.java
@@ -19,6 +19,7 @@
package org.eclipse.jetty.websocket.server;
import java.net.HttpCookie;
+import java.net.InetSocketAddress;
import java.security.Principal;
import java.util.ArrayList;
import java.util.Arrays;
@@ -108,11 +109,95 @@ public class ServletWebSocketRequest extends UpgradeRequest
}
}
+ /**
+ * Equivalent to {@link HttpServletRequest#getLocalAddr()}
+ *
+ * @return the local address
+ */
+ public String getLocalAddress()
+ {
+ return req.getLocalAddr();
+ }
+
+ /**
+ * Equivalent to {@link HttpServletRequest#getLocalName()}
+ *
+ * @return the local host name
+ */
+ public String getLocalHostName()
+ {
+ return req.getLocalName();
+ }
+
+ /**
+ * Equivalent to {@link HttpServletRequest#getLocalPort()}
+ *
+ * @return the local port
+ */
+ public int getLocalPort()
+ {
+ return req.getLocalPort();
+ }
+
+ /**
+ * Return a {@link InetSocketAddress} for the local socket.
+ *
+ * Warning: this can cause a DNS lookup
+ *
+ * @return the local socket address
+ */
+ public InetSocketAddress getLocalSocketAddress()
+ {
+ return new InetSocketAddress(req.getLocalAddr(),req.getLocalPort());
+ }
+
public Principal getPrincipal()
{
return req.getUserPrincipal();
}
+ /**
+ * Equivalent to {@link HttpServletRequest#getRemoteAddr()}
+ *
+ * @return the remote address
+ */
+ public String getRemoteAddress()
+ {
+ return req.getRemoteAddr();
+ }
+
+ /**
+ * Equivalent to {@link HttpServletRequest#getRemoteHost()}
+ *
+ * @return the remote host name
+ */
+ public String getRemoteHostName()
+ {
+ return req.getRemoteHost();
+ }
+
+ /**
+ * Equivalent to {@link HttpServletRequest#getRemotePort()}
+ *
+ * @return the remote port
+ */
+ public int getRemotePort()
+ {
+ return req.getRemotePort();
+ }
+
+ /**
+ * Return a {@link InetSocketAddress} for the remote socket.
+ *
+ * Warning: this can cause a DNS lookup
+ *
+ * @return the remote socket address
+ */
+ public InetSocketAddress getRemoteSocketAddress()
+ {
+ return new InetSocketAddress(req.getRemoteAddr(),req.getRemotePort());
+ }
+
public Map getServletAttributes()
{
Map attributes = new HashMap();
@@ -145,7 +230,7 @@ public class ServletWebSocketRequest extends UpgradeRequest
@Override
public Object getSession()
{
- return this.req.getSession();
+ return this.req.getSession(false);
}
protected String[] parseProtocols(String protocol)
diff --git a/jetty-xml/src/main/java/org/eclipse/jetty/xml/XmlConfiguration.java b/jetty-xml/src/main/java/org/eclipse/jetty/xml/XmlConfiguration.java
index 467f5d77bd8..f68a308b3ae 100644
--- a/jetty-xml/src/main/java/org/eclipse/jetty/xml/XmlConfiguration.java
+++ b/jetty-xml/src/main/java/org/eclipse/jetty/xml/XmlConfiguration.java
@@ -741,40 +741,41 @@ public class XmlConfiguration
private Object newObj(Object obj, XmlParser.Node node) throws Exception
{
Class oClass = nodeClass(node);
- int size = 0;
int argIndex = node.size();
+
+ Map namedArgMap = new HashMap<>();
+ List