Eclipse/jetty.project
1
0
Fork 0
mirror of https://github.com/jetty/jetty.project.git synced 2025-03-04 12:59:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Jetty9 - Removed old code not used anymore, greatly simplifying the implementation.

Browse Source
This commit is contained in:
Simone Bordet 2012-08-22 09:39:03 +02:00
parent 71e7f519c7
commit fa06ae9762
5 changed files with 589 additions and 1393 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
jetty-server/src/main/java/org/eclipse/jetty/server/Dispatcher.java
View File

@ -22,7 +22,6 @@ import java.io.IOException;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashSet;
import javax.servlet.DispatcherType;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
@ -38,8 +37,8 @@ import org.eclipse.jetty.util.UrlEncoded;
/* ------------------------------------------------------------ */
/** Servlet RequestDispatcher.
*
*
*
*
*/
public class Dispatcher implements RequestDispatcher
{
@ -58,7 +57,7 @@ public class Dispatcher implements RequestDispatcher
private final String _path;
private final String _dQuery;
private final String _named;
/* ------------------------------------------------------------ */
/**
* @param contextHandler
@ -77,7 +76,7 @@ public class Dispatcher implements RequestDispatcher
/* ------------------------------------------------------------ */
/** Constructor.
/** Constructor.
* @param contextHandler
* @param name
*/
@ -90,9 +89,9 @@ public class Dispatcher implements RequestDispatcher
_path=null;
_dQuery=null;
}
/* ------------------------------------------------------------ */
/*
/*
* @see javax.servlet.RequestDispatcher#forward(javax.servlet.ServletRequest, javax.servlet.ServletResponse)
*/
@Override
@ -100,34 +99,34 @@ public class Dispatcher implements RequestDispatcher
{
forward(request, response, DispatcherType.FORWARD);
}
/* ------------------------------------------------------------ */
/*
/*
* @see javax.servlet.RequestDispatcher#forward(javax.servlet.ServletRequest, javax.servlet.ServletResponse)
*/
public void error(ServletRequest request, ServletResponse response) throws ServletException, IOException
{
forward(request, response, DispatcherType.ERROR);
}
/* ------------------------------------------------------------ */
/*
/*
* @see javax.servlet.RequestDispatcher#include(javax.servlet.ServletRequest, javax.servlet.ServletResponse)
*/
@Override
public void include(ServletRequest request, ServletResponse response) throws ServletException, IOException
{
Request baseRequest=(request instanceof Request)?((Request)request):HttpChannel.getCurrentHttpChannel().getRequest();
if (!(request instanceof HttpServletRequest))
request = new ServletRequestHttpWrapper(request);
if (!(response instanceof HttpServletResponse))
response = new ServletResponseHttpWrapper(response);
// TODO - allow stream or writer????
final DispatcherType old_type = baseRequest.getDispatcherType();
final Attributes old_attr=baseRequest.getAttributes();
MultiMap<String> old_params=baseRequest.getParameters();
@ -137,10 +136,10 @@ public class Dispatcher implements RequestDispatcher
baseRequest.getResponse().include();
if (_named!=null)
_contextHandler.handle(_named,baseRequest, (HttpServletRequest)request, (HttpServletResponse)response);
else
else
{
String query=_dQuery;
if (query!=null)
{
// force parameter extraction
@ -149,27 +148,27 @@ public class Dispatcher implements RequestDispatcher
baseRequest.extractParameters();
old_params=baseRequest.getParameters();
}
MultiMap<String> parameters=new MultiMap<>();
UrlEncoded.decodeTo(query,parameters,baseRequest.getCharacterEncoding());
if(old_params != null) {
// Merge parameters.
parameters.addAllValues(old_params);
}
baseRequest.setParameters(parameters);
}
IncludeAttributes attr = new IncludeAttributes(old_attr);
IncludeAttributes attr = new IncludeAttributes(old_attr);
attr._requestURI=_uri;
attr._contextPath=_contextHandler.getContextPath();
attr._servletPath=null; // set by ServletHandler
attr._pathInfo=_path;
attr._query=query;
baseRequest.setAttributes(attr);
_contextHandler.handle(_path,baseRequest, (HttpServletRequest)request, (HttpServletResponse)response);
}
}
@ -182,24 +181,23 @@ public class Dispatcher implements RequestDispatcher
}
}
/* ------------------------------------------------------------ */
/*
/*
* @see javax.servlet.RequestDispatcher#forward(javax.servlet.ServletRequest, javax.servlet.ServletResponse)
*/
protected void forward(ServletRequest request, ServletResponse response, DispatcherType dispatch) throws ServletException, IOException
{
Request baseRequest=(request instanceof Request)?((Request)request):HttpChannel.getCurrentHttpChannel().getRequest();
Response base_response=baseRequest.getResponse();
response.resetBuffer();
base_response.fwdReset();
base_response.resetForForward();
if (!(request instanceof HttpServletRequest))
request = new ServletRequestHttpWrapper(request);
if (!(response instanceof HttpServletResponse))
response = new ServletResponseHttpWrapper(response);
final boolean old_handled=baseRequest.isHandled();
final String old_uri=baseRequest.getRequestURI();
final String old_context_path=baseRequest.getContextPath();
@ -209,17 +207,17 @@ public class Dispatcher implements RequestDispatcher
final Attributes old_attr=baseRequest.getAttributes();
final DispatcherType old_type=baseRequest.getDispatcherType();
MultiMap<String> old_params=baseRequest.getParameters();
try
{
baseRequest.setHandled(false);
baseRequest.setDispatcherType(dispatch);
if (_named!=null)
_contextHandler.handle(_named,baseRequest, (HttpServletRequest)request, (HttpServletResponse)response);
else
else
{
// process any query string from the dispatch URL
String query=_dQuery;
if (query!=null)
@ -230,13 +228,13 @@ public class Dispatcher implements RequestDispatcher
baseRequest.extractParameters();
old_params=baseRequest.getParameters();
}
baseRequest.mergeQueryString(query);
}
ForwardAttributes attr = new ForwardAttributes(old_attr);
//If we have already been forwarded previously, then keep using the established
ForwardAttributes attr = new ForwardAttributes(old_attr);
//If we have already been forwarded previously, then keep using the established
//original value. Otherwise, this is the first forward and we need to establish the values.
//Note: the established value on the original request for pathInfo and
//for queryString is allowed to be null, but cannot be null for the other values.
@ -255,16 +253,16 @@ public class Dispatcher implements RequestDispatcher
attr._requestURI=old_uri;
attr._contextPath=old_context_path;
attr._servletPath=old_servlet_path;
}
}
baseRequest.setRequestURI(_uri);
baseRequest.setContextPath(_contextHandler.getContextPath());
baseRequest.setServletPath(null);
baseRequest.setPathInfo(_uri);
baseRequest.setAttributes(attr);
_contextHandler.handle(_path,baseRequest, (HttpServletRequest)request, (HttpServletResponse)response);
if (!baseRequest.getAsyncContinuation().isAsyncStarted())
commitResponse(response,baseRequest);
}
@ -318,41 +316,41 @@ public class Dispatcher implements RequestDispatcher
private class ForwardAttributes implements Attributes
{
final Attributes _attr;
String _requestURI;
String _contextPath;
String _servletPath;
String _pathInfo;
String _query;
ForwardAttributes(Attributes attributes)
{
_attr=attributes;
}
/* ------------------------------------------------------------ */
public Object getAttribute(String key)
{
if (Dispatcher.this._named==null)
{
if (key.equals(FORWARD_PATH_INFO))
if (key.equals(FORWARD_PATH_INFO))
return _pathInfo;
if (key.equals(FORWARD_REQUEST_URI))
if (key.equals(FORWARD_REQUEST_URI))
return _requestURI;
if (key.equals(FORWARD_SERVLET_PATH))
if (key.equals(FORWARD_SERVLET_PATH))
return _servletPath;
if (key.equals(FORWARD_CONTEXT_PATH))
if (key.equals(FORWARD_CONTEXT_PATH))
return _contextPath;
if (key.equals(FORWARD_QUERY_STRING))
if (key.equals(FORWARD_QUERY_STRING))
return _query;
}
if (key.startsWith(__INCLUDE_PREFIX))
return null;
return _attr.getAttribute(key);
}
/* ------------------------------------------------------------ */
public Enumeration getAttributeNames()
{
@ -365,7 +363,7 @@ public class Dispatcher implements RequestDispatcher
!name.startsWith(__FORWARD_PREFIX))
set.add(name);
}
if (_named==null)
{
if (_pathInfo!=null)
@ -383,37 +381,37 @@ public class Dispatcher implements RequestDispatcher
return Collections.enumeration(set);
}
/* ------------------------------------------------------------ */
public void setAttribute(String key, Object value)
{
if (_named==null && key.startsWith("javax.servlet."))
{
if (key.equals(FORWARD_PATH_INFO))
if (key.equals(FORWARD_PATH_INFO))
_pathInfo=(String)value;
else if (key.equals(FORWARD_REQUEST_URI))
else if (key.equals(FORWARD_REQUEST_URI))
_requestURI=(String)value;
else if (key.equals(FORWARD_SERVLET_PATH))
else if (key.equals(FORWARD_SERVLET_PATH))
_servletPath=(String)value;
else if (key.equals(FORWARD_CONTEXT_PATH))
else if (key.equals(FORWARD_CONTEXT_PATH))
_contextPath=(String)value;
else if (key.equals(FORWARD_QUERY_STRING))
else if (key.equals(FORWARD_QUERY_STRING))
_query=(String)value;
else if (value==null)
_attr.removeAttribute(key);
else
_attr.setAttribute(key,value);
_attr.setAttribute(key,value);
}
else if (value==null)
_attr.removeAttribute(key);
else
_attr.setAttribute(key,value);
}
/* ------------------------------------------------------------ */
@Override
public String toString()
public String toString()
{
return "FORWARD+"+_attr.toString();
}
@ -435,18 +433,18 @@ public class Dispatcher implements RequestDispatcher
private class IncludeAttributes implements Attributes
{
final Attributes _attr;
String _requestURI;
String _contextPath;
String _servletPath;
String _pathInfo;
String _query;
IncludeAttributes(Attributes attributes)
{
_attr=attributes;
}
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
@ -460,13 +458,13 @@ public class Dispatcher implements RequestDispatcher
if (key.equals(INCLUDE_QUERY_STRING)) return _query;
if (key.equals(INCLUDE_REQUEST_URI)) return _requestURI;
}
else if (key.startsWith(__INCLUDE_PREFIX))
else if (key.startsWith(__INCLUDE_PREFIX))
return null;
return _attr.getAttribute(key);
}
/* ------------------------------------------------------------ */
public Enumeration getAttributeNames()
{
@ -478,7 +476,7 @@ public class Dispatcher implements RequestDispatcher
if (!name.startsWith(__INCLUDE_PREFIX))
set.add(name);
}
if (_named==null)
{
if (_pathInfo!=null)
@ -493,10 +491,10 @@ public class Dispatcher implements RequestDispatcher
else
set.remove(INCLUDE_QUERY_STRING);
}
return Collections.enumeration(set);
}
/* ------------------------------------------------------------ */
public void setAttribute(String key, Object value)
{
@ -510,17 +508,17 @@ public class Dispatcher implements RequestDispatcher
else if (value==null)
_attr.removeAttribute(key);
else
_attr.setAttribute(key,value);
_attr.setAttribute(key,value);
}
else if (value==null)
_attr.removeAttribute(key);
else
_attr.setAttribute(key,value);
}
/* ------------------------------------------------------------ */
@Override
public String toString()
public String toString()
{
return "INCLUDE+"+_attr.toString();
}

554
jetty-server/src/main/java/org/eclipse/jetty/server/HttpChannel.java
View File

@ -23,6 +23,7 @@ import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import javax.servlet.DispatcherType;
import javax.servlet.RequestDispatcher;
@ -48,9 +49,9 @@ import org.eclipse.jetty.util.URIUtil;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
public class HttpChannel
public class HttpChannel implements HttpParser.RequestHandler
{
protected static final Logger LOG = Log.getLogger(HttpChannel.class);
private static final Logger LOG = Log.getLogger(HttpChannel.class);
private static final ThreadLocal<HttpChannel> __currentChannel = new ThreadLocal<>();
public static HttpChannel getCurrentHttpChannel()
@ -64,7 +65,7 @@ public class HttpChannel
}
private final AtomicBoolean _committed = new AtomicBoolean();
private final ChannelEventHandler _handler = new ChannelEventHandler();
private final AtomicInteger _requests = new AtomicInteger();
private final Connector _connector;
private final HttpConfiguration _configuration;
private final EndPoint _endPoint;
@ -73,7 +74,6 @@ public class HttpChannel
private final HttpChannelState _state;
private final Request _request;
private final Response _response;
private int _requests;
private HttpVersion _version = HttpVersion.HTTP_1_1;
private boolean _expect = false;
private boolean _expect100Continue = false;
@ -98,22 +98,22 @@ public class HttpChannel
return _state;
}
public EventHandler getEventHandler()
{
return _handler;
}
public boolean isIdle()
{
return _state.isIdle();
}
/**
* @return the number of requests handled by this connection
*/
public int getRequests()
{
return _requests;
return _requests.get();
}
public Connector getConnector()
{
return _connector;
}
public HttpConfiguration getHttpConfiguration()
{
return _configuration;
}
public Server getServer()
@ -121,17 +121,11 @@ public class HttpChannel
return _connector.getServer();
}
/**
* @return Returns the request.
*/
public Request getRequest()
{
return _request;
}
/**
* @return Returns the response.
*/
public Response getResponse()
{
return _response;
@ -285,7 +279,7 @@ public class HttpChannel
// do anything special here other than make the connection not persistent
_expect100Continue = false;
if (!isCommitted())
_response.addHeader(HttpHeader.CONNECTION, HttpHeaderValue.CLOSE.toString());
_response.addHeader(HttpHeader.CONNECTION.toString(), HttpHeaderValue.CLOSE.toString());
else
LOG.warn("Cannot send 'Connection: close' for 100-Continue, response is already committed");
}
@ -310,78 +304,78 @@ public class HttpChannel
// TODO: remove this method
protected void completed()
{
/*
// This method is called by handle() when it knows that its handling of the request/response cycle
// is complete.
// This may happen in the original thread dispatched to the connection that has called handle(),
// or it may be from a thread dispatched to call handle() as the result of a resumed suspended request.
/*
// This method is called by handle() when it knows that its handling of the request/response cycle
// is complete.
// This may happen in the original thread dispatched to the connection that has called handle(),
// or it may be from a thread dispatched to call handle() as the result of a resumed suspended request.
LOG.debug("{} complete", this);
LOG.debug("{} complete", this);
// Handle connection upgrades
if (_response.getStatus() == HttpStatus.SWITCHING_PROTOCOLS_101)
{
Connection connection = (Connection)getRequest().getAttribute(HttpConnection.UPGRADE_CONNECTION_ATTRIBUTE);
if (connection != null)
{
LOG.debug("Upgrade from {} to {}", this, connection);
getEndPoint().setConnection(connection);
// HttpConnection.this.reset(); // TODO: this should be done by the connection privately when handle returns
return;
}
}
// Reset everything for the next cycle.
// HttpConnection.this.reset(); // TODO: this should be done by the connection privately when handle returns
// are called from non connection thread (ie dispatched from a resume)
if (getCurrentConnection()!=HttpConnection.this)
{
if (_parser.isStart())
{
// it wants to eat more
if (_requestBuffer==null)
fillInterested();
else if (getConnector().isStarted())
// Handle connection upgrades
if (_response.getStatus() == HttpStatus.SWITCHING_PROTOCOLS_101)
{
LOG.debug("{} pipelined",this);
try
Connection connection = (Connection)getRequest().getAttribute(HttpConnection.UPGRADE_CONNECTION_ATTRIBUTE);
if (connection != null)
{
execute(this);
}
catch(RejectedExecutionException e)
{
if (getConnector().isStarted())
LOG.warn(e);
else
LOG.ignore(e);
getEndPoint().close();
LOG.debug("Upgrade from {} to {}", this, connection);
getEndPoint().setConnection(connection);
// HttpConnection.this.reset(); // TODO: this should be done by the connection privately when handle returns
return;
}
}
else
getEndPoint().close();
}
if (_parser.isClosed()&&!getEndPoint().isOutputShutdown())
{
// TODO This is a catch all indicating some protocol handling failure
// Currently needed for requests saying they are HTTP/2.0.
// This should be removed once better error handling is in place
LOG.warn("Endpoint output not shutdown when seeking EOF");
getEndPoint().shutdownOutput();
}
}
// make sure that an oshut connection is driven towards close
// TODO this is a little ugly
if (getEndPoint().isOpen() && getEndPoint().isOutputShutdown())
{
fillInterested();
}
*/
// Reset everything for the next cycle.
// HttpConnection.this.reset(); // TODO: this should be done by the connection privately when handle returns
// are called from non connection thread (ie dispatched from a resume)
if (getCurrentConnection()!=HttpConnection.this)
{
if (_parser.isStart())
{
// it wants to eat more
if (_requestBuffer==null)
fillInterested();
else if (getConnector().isStarted())
{
LOG.debug("{} pipelined",this);
try
{
execute(this);
}
catch(RejectedExecutionException e)
{
if (getConnector().isStarted())
LOG.warn(e);
else
LOG.ignore(e);
getEndPoint().close();
}
}
else
getEndPoint().close();
}
if (_parser.isClosed()&&!getEndPoint().isOutputShutdown())
{
// TODO This is a catch all indicating some protocol handling failure
// Currently needed for requests saying they are HTTP/2.0.
// This should be removed once better error handling is in place
LOG.warn("Endpoint output not shutdown when seeking EOF");
getEndPoint().shutdownOutput();
}
}
// make sure that an oshut connection is driven towards close
// TODO this is a little ugly
if (getEndPoint().isOpen() && getEndPoint().isOutputShutdown())
{
fillInterested();
}
*/
}
/**
@ -390,6 +384,7 @@ public class HttpChannel
* <p>It may happen that the application suspends, and then throws an exception, while an application
* spawned thread writes the response content; in such case, we attempt to commit the error directly
* bypassing the {@link ErrorHandler} mechanisms and the response OutputStream.</p>
*
* @param x the Throwable that caused the problem
*/
private void handleError(Throwable x)
@ -479,10 +474,10 @@ public class HttpChannel
{
// TODO: not sure why we need to modify the request when writing an error ?
// TODO: or modify the response if the error code cannot have a body ?
// _channel.getRequest().getHttpFields().remove(HttpHeader.CONTENT_TYPE);
// _channel.getRequest().getHttpFields().remove(HttpHeader.CONTENT_LENGTH);
// _characterEncoding = null;
// _mimeType = null;
// _channel.getRequest().getHttpFields().remove(HttpHeader.CONTENT_TYPE);
// _channel.getRequest().getHttpFields().remove(HttpHeader.CONTENT_LENGTH);
// _characterEncoding = null;
// _mimeType = null;
}
complete();
@ -510,16 +505,6 @@ public class HttpChannel
return reason;
}
public boolean isSuspended()
{
return _request.getAsyncContinuation().isSuspended();
}
public void onClose()
{
LOG.debug("closed {}", this);
}
public boolean isExpecting100Continue()
{
return _expect100Continue;
@ -533,206 +518,203 @@ public class HttpChannel
@Override
public String toString()
{
return String.format("%s@%x{r=%d,a=%s}",
return String.format("%s@%x{r=%s,a=%s}",
getClass().getSimpleName(),
hashCode(),
_requests,
_state.getState());
}
private class ChannelEventHandler implements EventHandler
@Override
public boolean startRequest(HttpMethod httpMethod, String method, String uri, HttpVersion version)
{
@Override
public boolean startRequest(HttpMethod httpMethod, String method, String uri, HttpVersion version)
_host = false;
_expect = false;
_expect100Continue = false;
_expect102Processing = false;
if (_request.getTimeStamp() == 0)
_request.setTimeStamp(System.currentTimeMillis());
_request.setMethod(httpMethod, method);
if (httpMethod == HttpMethod.CONNECT)
_uri.parseConnect(uri);
else
_uri.parse(uri);
_request.setUri(_uri);
String path;
try
{
_host = false;
_expect = false;
_expect100Continue = false;
_expect102Processing = false;
if (_request.getTimeStamp() == 0)
_request.setTimeStamp(System.currentTimeMillis());
_request.setMethod(httpMethod, method);
if (httpMethod == HttpMethod.CONNECT)
_uri.parseConnect(uri);
else
_uri.parse(uri);
_request.setUri(_uri);
String path;
try
{
path = _uri.getDecodedPath();
}
catch (Exception e)
{
LOG.warn("Failed UTF-8 decode for request path, trying ISO-8859-1");
LOG.ignore(e);
path = _uri.getDecodedPath(StringUtil.__ISO_8859_1);
}
String info = URIUtil.canonicalPath(path);
if (info == null)
info = "/";
_request.setPathInfo(info);
_version = version == null ? HttpVersion.HTTP_0_9 : version;
_request.setHttpVersion(_version);
return false;
path = _uri.getDecodedPath();
}
@Override
public boolean parsedHeader(HttpHeader header, String name, String value)
catch (Exception e)
{
if (value == null)
value = "";
if (header != null)
LOG.warn("Failed UTF-8 decode for request path, trying ISO-8859-1");
LOG.ignore(e);
path = _uri.getDecodedPath(StringUtil.__ISO_8859_1);
}
String info = URIUtil.canonicalPath(path);
if (info == null)
info = "/";
_request.setPathInfo(info);
_version = version == null ? HttpVersion.HTTP_0_9 : version;
_request.setHttpVersion(_version);
return false;
}
@Override
public boolean parsedHeader(HttpHeader header, String name, String value)
{
if (value == null)
value = "";
if (header != null)
{
switch (header)
{
switch (header)
{
case HOST:
// TODO check if host matched a host in the URI.
_host = true;
break;
case HOST:
// TODO check if host matched a host in the URI.
_host = true;
break;
case EXPECT:
HttpHeaderValue expect = HttpHeaderValue.CACHE.get(value);
switch (expect == null ? HttpHeaderValue.UNKNOWN : expect)
{
case CONTINUE:
_expect100Continue = true;
break;
case EXPECT:
HttpHeaderValue expect = HttpHeaderValue.CACHE.get(value);
switch (expect == null ? HttpHeaderValue.UNKNOWN : expect)
{
case CONTINUE:
_expect100Continue = true;
break;
case PROCESSING:
_expect102Processing = true;
break;
case PROCESSING:
_expect102Processing = true;
break;
default:
String[] values = value.split(",");
for (int i = 0; values != null && i < values.length; i++)
default:
String[] values = value.split(",");
for (int i = 0; values != null && i < values.length; i++)
{
expect = HttpHeaderValue.CACHE.get(values[i].trim());
if (expect == null)
_expect = true;
else
{
expect = HttpHeaderValue.CACHE.get(values[i].trim());
if (expect == null)
_expect = true;
else
switch (expect)
{
switch (expect)
{
case CONTINUE:
_expect100Continue = true;
break;
case PROCESSING:
_expect102Processing = true;
break;
default:
_expect = true;
}
case CONTINUE:
_expect100Continue = true;
break;
case PROCESSING:
_expect102Processing = true;
break;
default:
_expect = true;
}
}
}
break;
}
}
break;
case CONTENT_TYPE:
MimeTypes.Type mime = MimeTypes.CACHE.get(value);
String charset = (mime == null || mime.getCharset() == null) ? MimeTypes.getCharsetFromContentType(value) : mime.getCharset().toString();
if (charset != null)
_request.setCharacterEncodingUnchecked(charset);
break;
case CONTENT_TYPE:
MimeTypes.Type mime = MimeTypes.CACHE.get(value);
String charset = (mime == null || mime.getCharset() == null) ? MimeTypes.getCharsetFromContentType(value) : mime.getCharset().toString();
if (charset != null)
_request.setCharacterEncodingUnchecked(charset);
break;
}
}
if (name != null)
_request.getHttpFields().add(name, value);
return false;
}
@Override
public boolean headerComplete()
{
_requests.incrementAndGet();
boolean persistent;
switch (_version)
{
case HTTP_0_9:
persistent = false;
break;
case HTTP_1_0:
persistent = _request.getHttpFields().contains(HttpHeader.CONNECTION, HttpHeaderValue.KEEP_ALIVE.asString());
if (persistent)
_response.getHttpFields().add(HttpHeader.CONNECTION, HttpHeaderValue.KEEP_ALIVE);
if (getServer().getSendDateHeader())
_response.getHttpFields().putDateField(HttpHeader.DATE.toString(), _request.getTimeStamp());
break;
case HTTP_1_1:
persistent = !_request.getHttpFields().contains(HttpHeader.CONNECTION, HttpHeaderValue.CLOSE.asString());
if (!persistent)
_response.getHttpFields().add(HttpHeader.CONNECTION, HttpHeaderValue.CLOSE);
if (getServer().getSendDateHeader())
_response.getHttpFields().putDateField(HttpHeader.DATE.toString(), _request.getTimeStamp());
if (!_host)
{
_response.sendError(Response.SC_BAD_REQUEST, "No Host Header", null);
return true;
}
}
if (name != null)
_request.getHttpFields().add(name, value);
return false;
if (_expect)
{
_response.sendError(Response.SC_EXPECTATION_FAILED, null, null);
return true;
}
break;
default:
throw new IllegalStateException();
}
@Override
public boolean headerComplete()
_request.setPersistent(persistent);
// Either handle now or wait for first content/message complete
return _expect100Continue;
}
@Override
public boolean content(ByteBuffer ref)
{
if (LOG.isDebugEnabled())
{
_requests++;
boolean persistent;
switch (_version)
{
case HTTP_0_9:
persistent = false;
break;
case HTTP_1_0:
persistent = _request.getHttpFields().contains(HttpHeader.CONNECTION, HttpHeaderValue.KEEP_ALIVE.asString());
if (persistent)
_response.getHttpFields().add(HttpHeader.CONNECTION, HttpHeaderValue.KEEP_ALIVE);
if (getServer().getSendDateHeader())
_response.getHttpFields().putDateField(HttpHeader.DATE.toString(), _request.getTimeStamp());
break;
case HTTP_1_1:
persistent = !_request.getHttpFields().contains(HttpHeader.CONNECTION, HttpHeaderValue.CLOSE.asString());
if (!persistent)
_response.getHttpFields().add(HttpHeader.CONNECTION, HttpHeaderValue.CLOSE);
if (getServer().getSendDateHeader())
_response.getHttpFields().putDateField(HttpHeader.DATE.toString(), _request.getTimeStamp());
if (!_host)
{
_response.sendError(Response.SC_BAD_REQUEST, "No Host Header", null);
return true;
}
if (_expect)
{
_response.sendError(Response.SC_EXPECTATION_FAILED, null, null);
return true;
}
break;
default:
throw new IllegalStateException();
}
_request.setPersistent(persistent);
// Either handle now or wait for first content/message complete
if (_expect100Continue)
return true;
return false;
LOG.debug("{} content {}", this, BufferUtil.toDetailString(ref));
}
_request.getHttpInput().content(ref);
return true;
}
@Override
public boolean content(ByteBuffer ref)
{
if (LOG.isDebugEnabled())
{
LOG.debug("{} content {}", this, BufferUtil.toDetailString(ref));
}
_request.getHttpInput().content(ref);
return true;
}
@Override
public boolean messageComplete(long contentLength)
{
_request.getHttpInput().shutdownInput();
return true;
}
@Override
public boolean messageComplete(long contentLength)
{
_request.getHttpInput().shutdownInput();
return true;
}
@Override
public boolean earlyEOF()
{
_request.getHttpInput().shutdownInput();
return false;
}
@Override
public boolean earlyEOF()
{
_request.getHttpInput().shutdownInput();
return false;
}
@Override
public void badMessage(int status, String reason)
{
if (status < 400 || status > 599)
status = HttpStatus.BAD_REQUEST_400;
_response.sendError(status, null, null);
}
@Override
public void badMessage(int status, String reason)
{
if (status < 400 || status > 599)
status = HttpStatus.BAD_REQUEST_400;
_response.sendError(status, null, null);
}
// TODO: port the logic present in this method
/*
@Override
public ResponseInfo commit()
{
@ -744,13 +726,7 @@ public class HttpChannel
}
return _response.commit();
}
@Override
public String toString()
{
return "CEH:" + HttpChannel.this.getEndPoint().toString();
}
}
*/
protected boolean commitResponse(ResponseInfo info, ByteBuffer content, boolean complete) throws IOException
{
@ -788,23 +764,6 @@ public class HttpChannel
}
}
public Connector getConnector()
{
return _connector;
}
public HttpConfiguration getHttpConfiguration()
{
return _configuration;
}
// protected abstract void flush(ByteBuffer content, boolean last) throws IOException;
// protected abstract FutureCallback<Void> write(ResponseInfo info, ByteBuffer content) throws IOException;
// protected abstract void completed();
// TODO: remove
protected void execute(Runnable task)
{
_connector.getExecutor().execute(task);
@ -815,9 +774,4 @@ public class HttpChannel
{
return _connector.getScheduler();
}
public interface EventHandler extends HttpParser.RequestHandler
{
ResponseInfo commit();
}
}

594
jetty-server/src/main/java/org/eclipse/jetty/server/HttpConnection.java
View File

@ -20,119 +20,81 @@ package org.eclipse.jetty.server;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ScheduledExecutorService;
import org.eclipse.jetty.http.HttpGenerator;
import org.eclipse.jetty.http.HttpGenerator.ResponseInfo;
import org.eclipse.jetty.http.HttpParser;
import org.eclipse.jetty.http.HttpStatus;
import org.eclipse.jetty.io.AbstractConnection;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.io.EofException;
import org.eclipse.jetty.util.BufferUtil;
import org.eclipse.jetty.util.FutureCallback;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
/**
* A Connection that handles the HTTP protocol
* <p>A {@link Connection} that handles the HTTP protocol.</p>
*/
public class HttpConnection extends AbstractConnection
{
private static final Logger LOG = Log.getLogger(HttpConnection.class);
private static final ThreadLocal<HttpConnection> __currentConnection = new ThreadLocal<>();
private static final FutureCallback<Void> __completed = new FutureCallback<>();
static
{
__completed.completed(null);
}
public static final String UPGRADE_CONNECTION_ATTRIBUTE = "org.eclispe.jetty.server.HttpConnection.UPGRADE";
private static final Logger LOG = Log.getLogger(HttpConnection.class);
private static final ThreadLocal<HttpConnection> __currentConnection = new ThreadLocal<>();
private final Server _server;
private final HttpConfiguration _httpConfig;
private final HttpConfiguration _configuration;
private final Connector _connector;
private final HttpParser _parser;
private final HttpGenerator _generator;
private final HttpChannel _channel;
private final ByteBufferPool _bufferPool;
private ResponseInfo _info;
private ByteBuffer _requestBuffer=null;
private ByteBuffer _chunk=null;
private ByteBuffer _requestBuffer = null;
private int _headerBytes;
/* ------------------------------------------------------------ */
public static HttpConnection getCurrentConnection()
{
return __currentConnection.get();
}
/* ------------------------------------------------------------ */
protected static void setCurrentConnection(HttpConnection connection)
{
__currentConnection.set(connection);
}
/* ------------------------------------------------------------ */
public HttpConnection(HttpConfiguration config, Connector connector, EndPoint endPoint)
{
super(endPoint,connector.getExecutor());
super(endPoint, connector.getExecutor());
_httpConfig=config;
_configuration = config;
_connector = connector;
_bufferPool=_connector.getByteBufferPool();
_bufferPool = _connector.getByteBufferPool();
_server = connector.getServer();
_channel = new HttpChannel(connector, config, endPoint, new HttpTransportOverHttp(_bufferPool, _httpConfig, endPoint));
_parser = new HttpParser(_channel.getEventHandler());
_channel = new HttpChannel(connector, config, endPoint, new HttpTransportOverHttp(_bufferPool, _configuration, endPoint));
_parser = new HttpParser(_channel);
_generator = new HttpGenerator();
_generator.setSendServerVersion(_server.getSendServerVersion());
LOG.debug("New HTTP Connection {}",this);
LOG.debug("New HTTP Connection {}", this);
}
/* ------------------------------------------------------------ */
/**
* @return the parser used by this connection
*/
public HttpParser getParser()
{
return _parser;
}
/* ------------------------------------------------------------ */
public Server getServer()
{
return _server;
}
/* ------------------------------------------------------------ */
/**
* @return Returns the connector.
*/
public Connector getConnector()
{
return _connector;
}
/* ------------------------------------------------------------ */
/**
* @return Returns the HttpChannel.
*/
public HttpChannel getHttpChannel()
{
return _channel;
}
/* ------------------------------------------------------------ */
public void reset()
{
if (_generator.isPersistent())
@ -143,21 +105,8 @@ public class HttpConnection extends AbstractConnection
_generator.reset();
_channel.reset();
releaseRequestBuffer();
if (_chunk!=null)
_bufferPool.release(_chunk);
_chunk=null;
_info=null;
}
/* ------------------------------------------------------------ */
public HttpGenerator getGenerator()
{
return _generator;
}
/* ------------------------------------------------------------ */
@Override
public String toString()
{
@ -167,60 +116,52 @@ public class HttpConnection extends AbstractConnection
_parser);
}
/* ------------------------------------------------------------ */
private void releaseRequestBuffer()
{
if (_requestBuffer!=null && !_requestBuffer.hasRemaining())
if (_requestBuffer != null && !_requestBuffer.hasRemaining())
{
_bufferPool.release(_requestBuffer);
_requestBuffer=null;
_requestBuffer = null;
}
}
/* ------------------------------------------------------------ */
/** Parse and handle HTTP messages.
* <p>
* This method is normally called as the {@link AbstractConnection} onReadable callback.
* However, it can also be called {@link HttpChannelOverHttp#completed()} if there is unconsumed
* data in the _requestBuffer, as a result of resuming a suspended request when there is a pipelined
* request already read into the buffer.
* <p>
* This method will fill data and parse it until either: EOF is filled; 0 bytes are filled;
* the HttpChannel becomes !idle; or the connection has been changed
/**
* <p>Parses and handles HTTP messages.</p>
* <p>This method is called when this {@link Connection} is ready to read bytes from the {@link EndPoint}.
* However, it can also be called if there is unconsumed data in the _requestBuffer, as a result of
* resuming a suspended request when there is a pipelined request already read into the buffer.</p>
* <p>This method fills bytes and parses them until either: EOF is filled; 0 bytes are filled;
* the HttpChannel finishes handling; or the connection has changed.</p>
*/
@Override
public void onFillable()
{
LOG.debug("{} onReadable {}",this,_channel.isIdle());
int filled=-2;
LOG.debug("{} onReadable {}", this, _channel.getState());
setCurrentConnection(this);
try
{
setCurrentConnection(this);
// TODO try to generalize this loop into AbstractConnection
while (true)
{
// Fill the request buffer with data only if it is totally empty.
if (BufferUtil.isEmpty(_requestBuffer))
{
if (_requestBuffer==null)
_requestBuffer=_bufferPool.acquire(_httpConfig.getRequestHeaderSize(),false); // TODO may acquire on speculative read. probably released to early
if (_requestBuffer == null)
_requestBuffer = _bufferPool.acquire(_configuration.getRequestHeaderSize(), false);
filled=getEndPoint().fill(_requestBuffer);
int filled = getEndPoint().fill(_requestBuffer);
LOG.debug("{} filled {}",this,filled);
LOG.debug("{} filled {}", this, filled);
// If we failed to fill
if (filled==0)
if (filled == 0)
{
// Somebody wanted to read, we didn't so schedule another attempt
releaseRequestBuffer();
fillInterested();
return;
}
else if (filled<0)
else if (filled < 0)
{
_parser.inputShutdown();
// We were only filling if fully consumed, so if we have
@ -237,7 +178,7 @@ public class HttpConnection extends AbstractConnection
}
else
{
_headerBytes+=filled;
_headerBytes += filled;
}
}
@ -245,7 +186,7 @@ public class HttpConnection extends AbstractConnection
if (_parser.parseNext(_requestBuffer))
{
// reset header count
_headerBytes=0;
_headerBytes = 0;
// For most requests, there will not be a body, so we can try to recycle the buffer now
releaseRequestBuffer();
@ -256,7 +197,7 @@ public class HttpConnection extends AbstractConnection
// The parser returned true, which indicates the channel is ready to handle a request.
// Call the channel and this will either handle the request/response to completion OR,
// if the request suspends, the request/response will be incomplete so the outer loop will exit.
boolean complete = _channel.handle();
boolean complete = _channel.handle(); // TODO: should we perform special processing if we are complete ?
// Handle connection upgrades
if (_channel.getResponse().getStatus() == HttpStatus.SWITCHING_PROTOCOLS_101)
@ -330,10 +271,10 @@ public class HttpConnection extends AbstractConnection
}
// return if the connection has been changed
if (getEndPoint().getConnection()!=this)
if (getEndPoint().getConnection() != this)
return;
}
else if (_headerBytes>= _httpConfig.getRequestHeaderSize())
else if (_headerBytes >= _configuration.getRequestHeaderSize())
{
_parser.reset();
_parser.close();
@ -342,17 +283,17 @@ public class HttpConnection extends AbstractConnection
}
}
}
catch(IOException e)
catch (IOException e)
{
if (_parser.isIdle())
LOG.debug(e);
else
LOG.warn(this.toString(),e);
LOG.warn(this.toString(), e);
getEndPoint().close();
}
catch(Exception e)
catch (Exception e)
{
LOG.warn(this.toString(),e);
LOG.warn(this.toString(), e);
getEndPoint().close();
}
finally
@ -361,471 +302,10 @@ public class HttpConnection extends AbstractConnection
}
}
/* ------------------------------------------------------------ */
@Override
public void onOpen()
{
super.onOpen();
fillInterested();
}
/* ------------------------------------------------------------ */
@Override
public void onClose()
{
super.onClose();
_channel.onClose();
}
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
private class HttpChannelOverHttp extends HttpChannel implements Runnable
{
private HttpChannelOverHttp(Server server)
{
super(_connector, _httpConfig, HttpConnection.this.getEndPoint(), new HttpTransportOverHttp(_bufferPool, _httpConfig, HttpConnection.this.getEndPoint()));
}
public Connector getConnector()
{
return _connector;
}
public HttpConfiguration getHttpConfiguration()
{
return _httpConfig;
}
// @Override
protected boolean commitError(int status, String reason, String content)
{
// if (!super.commitError(status,reason,content))
{
// TODO - should this just be a close and we don't worry about a RST overtaking a flushed response?
// We could not send the error, so a shutdown of the connection will at least tell
// the client something is wrong
getEndPoint().shutdownOutput();
_generator.abort();
// return false;
}
return true;
}
@Override
protected void completed()
{
// This is called by HttpChannel#handle when it knows that it's handling of the request/response cycle
// is complete. This may be in the original thread dispatched to the connection that has called process from
// the connection#onFillable method, or it may be from a thread dispatched to call process as the result
// of a resumed suspended request.
// At this point the HttpChannel will have completed the generation of any response (although it might remain to
// be asynchronously flushed TBD), but it may not have consumed the entire
LOG.debug("{} completed");
// Handle connection upgrades
if (getResponse().getStatus()==HttpStatus.SWITCHING_PROTOCOLS_101)
{
Connection connection=(Connection)getRequest().getAttribute(UPGRADE_CONNECTION_ATTRIBUTE);
if (connection!=null)
{
LOG.debug("Upgrade from {} to {}",this,connection);
getEndPoint().setConnection(connection);
HttpConnection.this.reset();
return;
}
}
// Reset everything for the next cycle.
HttpConnection.this.reset();
// are called from non connection thread (ie dispatched from a resume)
if (getCurrentConnection()!=HttpConnection.this)
{
if (_parser.isStart())
{
// it wants to eat more
if (_requestBuffer==null)
fillInterested();
else if (getConnector().isStarted())
{
LOG.debug("{} pipelined",this);
try
{
execute(this);
}
catch(RejectedExecutionException e)
{
if (getConnector().isStarted())
LOG.warn(e);
else
LOG.ignore(e);
getEndPoint().close();
}
}
else
getEndPoint().close();
}
if (_parser.isClosed()&&!getEndPoint().isOutputShutdown())
{
// TODO This is a catch all indicating some protocol handling failure
// Currently needed for requests saying they are HTTP/2.0.
// This should be removed once better error handling is in place
LOG.warn("Endpoint output not shutdown when seeking EOF");
getEndPoint().shutdownOutput();
}
}
// make sure that an oshut connection is driven towards close
// TODO this is a little ugly
if (getEndPoint().isOpen() && getEndPoint().isOutputShutdown())
{
fillInterested();
}
}
/* ------------------------------------------------------------ */
@Override
public void run()
{
onFillable();
}
/* ------------------------------------------------------------ */
// @Override
public void flush(ByteBuffer content, boolean last) throws IOException
{
// Only one response writer at a time.
synchronized(this)
{
ByteBuffer header=null;
try
{
if (_generator.isEnd())
{
// TODO do we need this escape?
if (last && BufferUtil.isEmpty(content))
return;
throw new EofException();
}
loop: while (true)
{
HttpGenerator.Result result=_generator.generateResponse(_info,header,content,last);
if (LOG.isDebugEnabled())
LOG.debug("{} generate: {} ({},{},{})@{}",
this,
result,
BufferUtil.toSummaryString(header),
BufferUtil.toSummaryString(content),
last,
_generator.getState());
switch(result)
{
case NEED_INFO:
if (_info==null)
_info=_channel.getEventHandler().commit();
continue;
case NEED_HEADER:
if (header!=null)
_bufferPool.release(header);
header=_bufferPool.acquire(_httpConfig.getResponseHeaderSize(),false);
continue;
case NEED_CHUNK:
if (header!=null)
_bufferPool.release(header);
header=_bufferPool.acquire(HttpGenerator.CHUNK_SIZE,false);
continue;
case FLUSH:
if (_info.isHead())
{
write(header,null).get();
BufferUtil.clear(content);
}
else
write(header,content).get();
continue;
case SHUTDOWN_OUT:
getEndPoint().shutdownOutput();
continue;
case DONE:
break loop;
}
}
}
catch(InterruptedException e)
{
LOG.debug(e);
}
catch(ExecutionException e)
{
LOG.debug(e);
if (e.getCause() instanceof IOException)
throw (IOException)e.getCause();
throw new RuntimeException(e);
}
finally
{
if (header!=null)
_bufferPool.release(header);
}
}
}
// @Override
protected FutureCallback<Void> write(ResponseInfo info, ByteBuffer content) throws IOException
{
// Only one response writer at a time.
synchronized(this)
{
ByteBuffer header=null;
try
{
if (_generator.isEnd())
throw new EofException();
FutureCallback<Void> fcb=null;
loop: while (true)
{
HttpGenerator.Result result=_generator.generateResponse(info,header,content,true);
if (LOG.isDebugEnabled())
LOG.debug("{} send: {} ({},{})@{}",
this,
result,
BufferUtil.toSummaryString(header),
BufferUtil.toSummaryString(content),
_generator.getState());
switch(result)
{
case NEED_INFO:
throw new IllegalStateException();
case NEED_HEADER:
if (header!=null)
_bufferPool.release(header);
header=_bufferPool.acquire(_httpConfig.getResponseHeaderSize(),false);
continue;
case NEED_CHUNK:
if (header!=null)
_bufferPool.release(header);
header=_bufferPool.acquire(HttpGenerator.CHUNK_SIZE,false);
continue;
case FLUSH:
if(info.isHead())
{
BufferUtil.clear(content);
fcb=write(header,null);
}
else
fcb=write(header,content);
continue;
case SHUTDOWN_OUT:
getEndPoint().shutdownOutput();
continue;
case DONE:
if (fcb==null)
fcb=__completed;
break loop;
}
}
return fcb;
}
finally
{
if (header!=null)
_bufferPool.release(header);
}
}
}
@Override
public ScheduledExecutorService getScheduler()
{
return _connector.getScheduler();
}
@Override
protected void execute(Runnable task)
{
_connector.getExecutor().execute(task);
}
private FutureCallback<Void> write(ByteBuffer b0,ByteBuffer b1)
{
FutureCallback<Void> fcb=new FutureCallback<>();
if (BufferUtil.hasContent(b0))
{
if (BufferUtil.hasContent(b1))
{
getEndPoint().write(null,fcb,b0,b1);
}
else
{
getEndPoint().write(null,fcb,b0);
}
}
else
{
if (BufferUtil.hasContent(b1))
{
getEndPoint().write(null,fcb,b1);
}
else
{
fcb.completed(null);
}
}
return fcb;
}
}
private class HttpHttpInput extends HttpInput
{
@Override
protected void blockForContent() throws IOException
{
/* We extend the blockForContent method to replace the
default implementation of a blocking queue with an implementation
that uses the calling thread to block on a readable callback and
then to do the parsing before before attempting the read.
*/
// While progress and the connection has not changed
boolean parsed_event=_parser.parseNext(_requestBuffer==null?BufferUtil.EMPTY_BUFFER:_requestBuffer);
while (!parsed_event && !getEndPoint().isInputShutdown())
{
try
{
// Do we have content ready to parse?
if (BufferUtil.isEmpty(_requestBuffer))
{
// Wait until we can read
FutureCallback<Void> block=new FutureCallback<>();
getEndPoint().fillInterested(null,block);
LOG.debug("{} block readable on {}",this,block);
block.get();
// We will need a buffer to read into
if (_requestBuffer==null)
_requestBuffer=_bufferPool.acquire(_httpConfig.getRequestBufferSize(),false);
int filled=getEndPoint().fill(_requestBuffer);
LOG.debug("{} block filled {}",this,filled);
if (filled<0)
_parser.inputShutdown();
}
// If we parse to an event, return
while (BufferUtil.hasContent(_requestBuffer) && _parser.inContentState())
parsed_event|=_parser.parseNext(_requestBuffer);
if (parsed_event)
return;
}
catch (InterruptedException e)
{
LOG.debug(e);
}
catch (ExecutionException e)
{
LOG.debug(e);
FutureCallback.rethrow(e);
}
}
}
@Override
public int available()
{
int available=super.available();
if (available==0 && _parser.isInContent() && BufferUtil.hasContent(_requestBuffer))
return 1;
return available;
}
@Override
public void consumeAll()
{
// Consume content only if the connection is persistent
if (!_generator.isPersistent())
{
_parser.setState(HttpParser.State.CLOSED);
synchronized (lock())
{
_inputQ.clear();
}
}
else
{
while (true)
{
synchronized (lock())
{
_inputQ.clear();
}
if (_parser.isComplete() || _parser.isClosed())
return;
try
{
blockForContent();
}
catch(IOException e)
{
LOG.warn(e);
}
}
}
}
@Override
protected void onContentQueued(ByteBuffer ref)
{
/* This callback could be used to tell the connection
* that the request did contain content and thus the request
* buffer needs to be held until a call to #onAllContentConsumed
*
* However it turns out that nothing is needed here because either a
* request will have content, in which case the request buffer will be
* released by a call to onAllContentConsumed; or it will not have content.
* If it does not have content, either it will complete quickly and the
* buffers will be released in completed() or it will be suspended and
* onReadable() contains explicit handling to release if it is suspended.
*
* We extend this method anyway, to turn off the notify done by the
* default implementation as this is not needed by our implementation
* of blockForContent
*/
}
@Override
protected void onAllContentConsumed()
{
/* This callback tells the connection that all content that has
* been parsed has been consumed. Thus the request buffer may be
* released if it is empty.
*/
releaseRequestBuffer();
}
}
}

648
jetty-server/src/main/java/org/eclipse/jetty/server/Response.java
View File

File diff suppressed because it is too large Load Diff

30
jetty-server/src/test/java/org/eclipse/jetty/server/HttpConnectionTest.java
View File

@ -24,16 +24,9 @@
*/
package org.eclipse.jetty.server;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.startsWith;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.concurrent.TimeUnit;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@ -50,6 +43,12 @@ import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.startsWith;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
/**
*
*/
@ -126,7 +125,7 @@ public class HttpConnectionTest
System.err.println(response);
}
}
@Test
public void testNoPath() throws Exception
{
@ -139,7 +138,7 @@ public class HttpConnectionTest
offset = checkContains(response,offset,"HTTP/1.1 200");
checkContains(response,offset,"pathInfo=/");
}
@Test
public void testEmpty() throws Exception
@ -199,15 +198,15 @@ public class HttpConnectionTest
"Connection: close\n"+
"\015\012");
checkContains(response,0,"HTTP/1.1 400");
response=connector.getResponses("GET /foo/bar%c0%00 HTTP/1.1\n"+
"Host: localhost\n"+
"Connection: close\n"+
"Connection: close\n"+
"\015\012");
checkContains(response,0,"HTTP/1.1 200"); //now fallback to iso-8859-1
response=connector.getResponses("GET /bad/utf8%c1 HTTP/1.1\n"+
"Host: localhost\n"+
"Host: localhost\n"+
"Connection: close\n"+
"\015\012");
checkContains(response,0,"HTTP/1.1 200"); //now fallback to iso-8859-1
@ -360,10 +359,11 @@ public class HttpConnectionTest
"\n"+
"abcdefghij\n";
Logger logger = Log.getLogger(HttpChannel.class);
try
{
HttpChannel.LOG.info("EXPECTING: java.lang.IllegalStateException...");
((StdErrLog)Log.getLogger(HttpChannel.class)).setHideStacks(true);
logger.info("EXPECTING: java.lang.IllegalStateException...");
((StdErrLog)logger).setHideStacks(true);
response=connector.getResponses(requests);
offset = checkContains(response,offset,"HTTP/1.1 500");
offset = checkContains(response,offset,"Connection: close");
@ -371,7 +371,7 @@ public class HttpConnectionTest
}
finally
{
((StdErrLog)Log.getLogger(HttpChannel.class)).setHideStacks(false);
((StdErrLog)logger).setHideStacks(false);
}
}