entry : results.entrySet())
{
if (uri.startsWith(entry.getKey()))
return entry.getValue();
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpClient.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpClient.java
index aada2edfccd..dba21c5dc61 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpClient.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpClient.java
@@ -69,6 +69,7 @@ import org.eclipse.jetty.util.thread.TimerScheduler;
* and HTTP parameters (such as whether to follow redirects).
* {@link HttpClient} transparently pools connections to servers, but allows direct control of connections
* for cases where this is needed.
+ * {@link HttpClient} also acts as a central configuration point for cookies, via {@link #getCookieStore()}.
* Typical usage:
*
* // One liner:
@@ -264,6 +265,11 @@ public class HttpClient extends AggregateLifeCycle
}
public Destination getDestination(String scheme, String host, int port)
+ {
+ return provideDestination(scheme, host, port);
+ }
+
+ private HttpDestination provideDestination(String scheme, String host, int port)
{
String address = address(scheme, host, port);
HttpDestination destination = destinations.get(address);
@@ -321,7 +327,7 @@ public class HttpClient extends AggregateLifeCycle
if (port < 0)
port = "https".equals(scheme) ? 443 : 80;
- getDestination(scheme, host, port).send(request, listener);
+ provideDestination(scheme, host, port).send(request, listener);
}
public Executor getExecutor()
@@ -438,7 +444,7 @@ public class HttpClient extends AggregateLifeCycle
}
// TODO: find a better method name
- public Response.Listener lookup(Request request, Response response)
+ protected Response.Listener lookup(Request request, Response response)
{
for (ProtocolHandler handler : handlers)
{
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpConnection.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpConnection.java
index 4f1e3286b7e..c7a03c02dbe 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpConnection.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpConnection.java
@@ -146,7 +146,7 @@ public class HttpConnection extends AbstractConnection implements Connection
}
// Cookies
- List cookies = client.getCookieStore().getCookies(getDestination(), request.path());
+ List cookies = client.getCookieStore().findCookies(getDestination(), request.path());
StringBuilder cookieString = null;
for (int i = 0; i < cookies.size(); ++i)
{
@@ -161,9 +161,9 @@ public class HttpConnection extends AbstractConnection implements Connection
request.header(HttpHeader.COOKIE.asString(), cookieString.toString());
// Authorization
- Authentication authentication = client.getAuthenticationStore().findAuthenticationResult(request.uri());
- if (authentication != null)
- authentication.authenticate(request);
+ Authentication.Result authnResult = client.getAuthenticationStore().findAuthenticationResult(request.uri());
+ if (authnResult != null)
+ authnResult.apply(request);
// TODO: decoder headers
@@ -250,6 +250,11 @@ public class HttpConnection extends AbstractConnection implements Connection
}
}
+ public void abort(HttpResponse response)
+ {
+ receiver.fail(new HttpResponseException("Response aborted", response));
+ }
+
@Override
public void close()
{
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpCookieStore.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpCookieStore.java
index a198514c9c8..043447b3578 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpCookieStore.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpCookieStore.java
@@ -35,7 +35,7 @@ public class HttpCookieStore implements CookieStore
private final ConcurrentMap> allCookies = new ConcurrentHashMap<>();
@Override
- public List getCookies(Destination destination, String path)
+ public List findCookies(Destination destination, String path)
{
List result = new ArrayList<>();
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpDestination.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpDestination.java
index 894c48da364..7d965ec580c 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpDestination.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpDestination.java
@@ -91,7 +91,6 @@ public class HttpDestination implements Destination, AutoCloseable
return port;
}
- @Override
public void send(Request request, Response.Listener listener)
{
if (!scheme.equals(request.scheme()))
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpExchange.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpExchange.java
index 26024e83c96..4e6f669bc10 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpExchange.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpExchange.java
@@ -42,7 +42,7 @@ public class HttpExchange
this.connection = connection;
this.request = request;
this.listener = listener;
- this.response = new HttpResponse(listener);
+ this.response = new HttpResponse(this, listener);
}
public HttpConversation conversation()
@@ -117,6 +117,12 @@ public class HttpExchange
return false;
}
+ public void abort()
+ {
+ LOG.debug("Aborting {}", response);
+ connection.abort(response);
+ }
+
@Override
public String toString()
{
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpRequest.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpRequest.java
index 3ecda154f2b..f3695916768 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpRequest.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpRequest.java
@@ -27,38 +27,37 @@ import java.nio.file.Path;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicLong;
-import org.eclipse.jetty.client.api.ContentDecoder;
import org.eclipse.jetty.client.api.ContentProvider;
import org.eclipse.jetty.client.api.ContentResponse;
import org.eclipse.jetty.client.api.Request;
import org.eclipse.jetty.client.api.Response;
-import org.eclipse.jetty.client.api.Result;
-import org.eclipse.jetty.client.util.BufferingResponseListener;
+import org.eclipse.jetty.client.util.BlockingResponseListener;
import org.eclipse.jetty.client.util.PathContentProvider;
import org.eclipse.jetty.http.HttpFields;
import org.eclipse.jetty.http.HttpHeader;
import org.eclipse.jetty.http.HttpMethod;
import org.eclipse.jetty.http.HttpVersion;
import org.eclipse.jetty.util.Fields;
-import org.eclipse.jetty.util.FutureCallback;
public class HttpRequest implements Request
{
private static final AtomicLong ids = new AtomicLong();
+ private final HttpFields headers = new HttpFields();
+ private final Fields params = new Fields();
private final HttpClient client;
private final long id;
- private String scheme;
private final String host;
private final int port;
+ private String scheme;
private String path;
private HttpMethod method;
private HttpVersion version;
private long idleTimeout;
private Listener listener;
private ContentProvider content;
- private final HttpFields headers = new HttpFields();
- private final Fields params = new Fields();
+ private boolean followRedirects;
+ private volatile boolean aborted;
public HttpRequest(HttpClient client, URI uri)
{
@@ -82,6 +81,7 @@ public class HttpRequest implements Request
param(parts[0], parts.length < 2 ? "" : urlDecode(parts[1]));
}
}
+ followRedirects(client.isFollowRedirects());
}
private String urlDecode(String value)
@@ -199,9 +199,9 @@ public class HttpRequest implements Request
}
@Override
- public Request agent(String userAgent)
+ public Request agent(String agent)
{
- headers.put(HttpHeader.USER_AGENT, userAgent);
+ headers.put(HttpHeader.USER_AGENT, agent);
return this;
}
@@ -261,15 +261,22 @@ public class HttpRequest implements Request
return content(new PathContentProvider(file));
}
+// @Override
+// public Request decoder(ContentDecoder decoder)
+// {
+// return this;
+// }
+
@Override
- public Request decoder(ContentDecoder decoder)
+ public boolean followRedirects()
{
- return this;
+ return followRedirects;
}
@Override
public Request followRedirects(boolean follow)
{
+ this.followRedirects = follow;
return this;
}
@@ -289,22 +296,9 @@ public class HttpRequest implements Request
@Override
public Future send()
{
- final FutureCallback callback = new FutureCallback<>();
- BufferingResponseListener listener = new BufferingResponseListener()
- {
- @Override
- public void onComplete(Result result)
- {
- super.onComplete(result);
- HttpContentResponse contentResponse = new HttpContentResponse(result.getResponse(), content());
- if (!result.isFailed())
- callback.completed(contentResponse);
- else
- callback.failed(contentResponse, result.getFailure());
- }
- };
+ BlockingResponseListener listener = new BlockingResponseListener();
send(listener);
- return callback;
+ return listener;
}
@Override
@@ -313,6 +307,18 @@ public class HttpRequest implements Request
client.send(this, listener);
}
+ @Override
+ public void abort()
+ {
+ aborted = true;
+ }
+
+ @Override
+ public boolean aborted()
+ {
+ return aborted;
+ }
+
@Override
public String toString()
{
diff --git a/jetty-server/src/test/java/org/eclipse/jetty/server/ChannelHttpServer.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpRequestException.java
similarity index 65%
rename from jetty-server/src/test/java/org/eclipse/jetty/server/ChannelHttpServer.java
rename to jetty-client/src/main/java/org/eclipse/jetty/client/HttpRequestException.java
index 51842cbbb86..0541eee14ca 100644
--- a/jetty-server/src/test/java/org/eclipse/jetty/server/ChannelHttpServer.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpRequestException.java
@@ -16,19 +16,22 @@
// ========================================================================
//
-package org.eclipse.jetty.server;
+package org.eclipse.jetty.client;
-public class ChannelHttpServer
+import org.eclipse.jetty.client.api.Request;
+
+public class HttpRequestException extends Throwable
{
- public static void main(String[] s) throws Exception
+ private final Request request;
+
+ public HttpRequestException(String message, Request request)
{
- Server server = new Server();
- SelectChannelConnector connector = new SelectChannelConnector(server);
- connector.setPort(8080);
- server.addConnector(connector);
- server.setHandler(new DumpHandler());
- server.start();
- server.dumpStdErr();
- server.join();
+ super(message);
+ this.request = request;
+ }
+
+ public Request getRequest()
+ {
+ return request;
}
}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpResponse.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpResponse.java
index 5f9c2468574..42be83cc9c3 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpResponse.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpResponse.java
@@ -25,13 +25,15 @@ import org.eclipse.jetty.http.HttpVersion;
public class HttpResponse implements Response
{
private final HttpFields headers = new HttpFields();
+ private final HttpExchange exchange;
private final Listener listener;
private HttpVersion version;
private int status;
private String reason;
- public HttpResponse(Response.Listener listener)
+ public HttpResponse(HttpExchange exchange, Listener listener)
{
+ this.exchange = exchange;
this.listener = listener;
}
@@ -84,7 +86,7 @@ public class HttpResponse implements Response
@Override
public void abort()
{
-// request.abort();
+ exchange.abort();
}
@Override
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpSender.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpSender.java
index a9308d31353..e75854fc1bf 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpSender.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpSender.java
@@ -60,12 +60,20 @@ public class HttpSender
public void send(HttpExchange exchange)
{
- LOG.debug("Sending {}", exchange.request());
- requestNotifier.notifyBegin(exchange.request());
- ContentProvider content = exchange.request().content();
- this.contentLength = content == null ? -1 : content.length();
- this.contentChunks = content == null ? Collections.emptyIterator() : content.iterator();
- send();
+ Request request = exchange.request();
+ if (request.aborted())
+ {
+ fail(new HttpRequestException("Request aborted", request));
+ }
+ else
+ {
+ LOG.debug("Sending {}", request);
+ requestNotifier.notifyBegin(request);
+ ContentProvider content = request.content();
+ this.contentLength = content == null ? -1 : content.length();
+ this.contentChunks = content == null ? Collections.emptyIterator() : content.iterator();
+ send();
+ }
}
private void send()
@@ -122,38 +130,45 @@ public class HttpSender
}
case FLUSH:
{
- StatefulExecutorCallback callback = new StatefulExecutorCallback(client.getExecutor())
+ if (request.aborted())
{
- @Override
- protected void pendingCompleted()
+ fail(new HttpRequestException("Request aborted", request));
+ }
+ else
+ {
+ StatefulExecutorCallback callback = new StatefulExecutorCallback(client.getExecutor())
+ {
+ @Override
+ protected void pendingCompleted()
+ {
+ if (!committed)
+ committed(request);
+ send();
+ }
+
+ @Override
+ protected void failed(Throwable x)
+ {
+ fail(x);
+ }
+ };
+ if (header == null)
+ header = BufferUtil.EMPTY_BUFFER;
+ if (chunk == null)
+ chunk = BufferUtil.EMPTY_BUFFER;
+ endPoint.write(null, callback, header, chunk, content);
+ if (callback.pending())
+ return;
+
+ if (callback.completed())
{
if (!committed)
committed(request);
- send();
+
+ releaseBuffers();
+ content = contentChunks.hasNext() ? contentChunks.next() : BufferUtil.EMPTY_BUFFER;
+ lastContent = !contentChunks.hasNext();
}
-
- @Override
- protected void failed(Throwable x)
- {
- fail(x);
- }
- };
- if (header == null)
- header = BufferUtil.EMPTY_BUFFER;
- if (chunk == null)
- chunk = BufferUtil.EMPTY_BUFFER;
- endPoint.write(null, callback, header, chunk, content);
- if (callback.pending())
- return;
-
- if (callback.completed())
- {
- if (!committed)
- committed(request);
-
- releaseBuffers();
- content = contentChunks.hasNext() ? contentChunks.next() : BufferUtil.EMPTY_BUFFER;
- lastContent = !contentChunks.hasNext();
}
break;
}
@@ -234,7 +249,7 @@ public class HttpSender
// Notify after
HttpExchange exchange = connection.getExchange();
Request request = exchange.request();
- LOG.debug("Failed {}", request);
+ LOG.debug("Failed {} {}", request, failure);
boolean exchangeCompleted = exchange.requestComplete(false);
if (!exchangeCompleted && !committed)
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/RedirectProtocolHandler.java b/jetty-client/src/main/java/org/eclipse/jetty/client/RedirectProtocolHandler.java
index 180e66098a7..588b1fffb6c 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/RedirectProtocolHandler.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/RedirectProtocolHandler.java
@@ -24,7 +24,7 @@ import org.eclipse.jetty.client.api.Result;
import org.eclipse.jetty.http.HttpFields;
import org.eclipse.jetty.http.HttpMethod;
-public class RedirectProtocolHandler extends Response.Listener.Adapter implements ProtocolHandler
+public class RedirectProtocolHandler extends Response.Listener.Empty implements ProtocolHandler
{
private static final String ATTRIBUTE = RedirectProtocolHandler.class.getName() + ".redirect";
@@ -45,7 +45,7 @@ public class RedirectProtocolHandler extends Response.Listener.Adapter implement
case 302:
case 303:
case 307:
- return true;
+ return request.followRedirects();
}
return false;
}
@@ -128,7 +128,7 @@ public class RedirectProtocolHandler extends Response.Listener.Adapter implement
// Copy content
redirect.content(request.content());
- redirect.send(new Adapter());
+ redirect.send(new Response.Listener.Empty());
}
else
{
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/api/Authentication.java b/jetty-client/src/main/java/org/eclipse/jetty/client/api/Authentication.java
index 5aa17ee98d4..05ad760a525 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/api/Authentication.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/api/Authentication.java
@@ -18,31 +18,67 @@
package org.eclipse.jetty.client.api;
+import org.eclipse.jetty.util.Attributes;
+
+/**
+ * {@link Authentication} represents a mechanism to authenticate requests for protected resources.
+ *
+ * {@link Authentication}s are added to an {@link AuthenticationStore}, which is then
+ * {@link #matches(String, String, String) queried} to find the right
+ * {@link Authentication} mechanism to use based on its type, URI and realm, as returned by
+ * {@code WWW-Authenticate} response headers.
+ *
+ * If an {@link Authentication} mechanism is found, it is then
+ * {@link #authenticate(Request, ContentResponse, String, Attributes) executed} for the given request,
+ * returning an {@link Authentication.Result}, which is then stored in the {@link AuthenticationStore}
+ * so that subsequent requests can be preemptively authenticated.
+ */
public interface Authentication
{
+ /**
+ * Matches {@link Authentication}s based on the given parameters
+ * @param type the {@link Authentication} type such as "Basic" or "Digest"
+ * @param uri the request URI
+ * @param realm the authentication realm as provided in the {@code WWW-Authenticate} response header
+ * @return true if this authentication matches, false otherwise
+ */
boolean matches(String type, String uri, String realm);
- void authenticate(Request request);
+ /**
+ * Executes the authentication mechanism for the given request, returning a {@link Result} that can be
+ * used to actually authenticate the request via {@link Result#apply(Request)}.
+ *
+ * If a request for {@code "/secure"} returns a {@link Result}, then the result may be used for other
+ * requests such as {@code "/secure/foo"} or {@code "/secure/bar"}, unless those resources are protected
+ * by other realms.
+ *
+ * @param request the request to execute the authentication mechanism for
+ * @param response the 401 response obtained in the previous attempt to request the protected resource
+ * @param wwwAuthenticate the {@code WWW-Authenticate} header chosen for this authentication
+ * (among the many that the response may contain)
+ * @param context the conversation context in case the authentication needs multiple exchanges
+ * to be completed and information needs to be stored across exchanges
+ * @return the authentication result, or null if the authentication could not be performed
+ */
+ Result authenticate(Request request, ContentResponse response, String wwwAuthenticate, Attributes context);
- public static class Result
+ /**
+ * {@link Result} holds the information needed to authenticate a {@link Request} via {@link #apply(Request)}.
+ */
+ public static interface Result
{
- private final String uri;
- private final Authentication authentication;
+ /**
+ * @return the URI of the request that has been used to generate this {@link Result}
+ */
+ String getURI();
- public Result(String uri, Authentication authentication)
- {
- this.uri = uri;
- this.authentication = authentication;
- }
-
- public String getURI()
- {
- return uri;
- }
-
- public Authentication getAuthentication()
- {
- return authentication;
- }
+ /**
+ * Applies the authentication result to the given request.
+ * Typically, a {@code Authorization} header is added to the request, with the right information to
+ * successfully authenticate at the server.
+ *
+ * @param request the request to authenticate
+ */
+ void apply(Request request);
}
}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/api/AuthenticationStore.java b/jetty-client/src/main/java/org/eclipse/jetty/client/api/AuthenticationStore.java
index afdcea697f2..2835ed73fcc 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/api/AuthenticationStore.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/api/AuthenticationStore.java
@@ -18,17 +18,54 @@
package org.eclipse.jetty.client.api;
+/**
+ * A store for {@link Authentication}s and {@link Authentication.Result}s.
+ */
public interface AuthenticationStore
{
+ /**
+ * @param authentication the {@link Authentication} to add
+ */
public void addAuthentication(Authentication authentication);
+ /**
+ * @param authentication the {@link Authentication} to remove
+ */
public void removeAuthentication(Authentication authentication);
+ /**
+ * Returns the authentication that matches the given type (for example, "Basic" or "Digest"),
+ * the given request URI and the given realm.
+ * If no such authentication can be found, returns null.
+ *
+ * @param type the {@link Authentication} type such as "Basic" or "Digest"
+ * @param uri the request URI
+ * @param realm the authentication realm
+ * @return the authentication that matches the given parameters, or null
+ */
public Authentication findAuthentication(String type, String uri, String realm);
+ /**
+ * @param result the {@link Authentication.Result} to add
+ */
public void addAuthenticationResult(Authentication.Result result);
- public void removeAuthenticationResults();
+ /**
+ * @param result the {@link Authentication.Result} to remove
+ */
+ public void removeAuthenticationResult(Authentication.Result result);
- public Authentication findAuthenticationResult(String uri);
+ /**
+ * Removes all authentication results stored
+ */
+ public void clearAuthenticationResults();
+
+ /**
+ * Returns an {@link Authentication.Result} that matches the given URI, or null if no
+ * {@link Authentication.Result}s match the given URI.
+ *
+ * @param uri the request URI
+ * @return the {@link Authentication.Result} that matches the given URI, or null
+ */
+ public Authentication.Result findAuthenticationResult(String uri);
}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/api/Connection.java b/jetty-client/src/main/java/org/eclipse/jetty/client/api/Connection.java
index 1d7be57c75d..23d963ca5c8 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/api/Connection.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/api/Connection.java
@@ -18,8 +18,25 @@
package org.eclipse.jetty.client.api;
+/**
+ * {@link Connection} represent a connection to a {@link Destination} and allow applications to send
+ * requests via {@link #send(Request, Response.Listener)}.
+ *
+ * {@link Connection}s are normally pooled by {@link Destination}s, but unpooled {@link Connection}s
+ * may be created by applications that want to do their own connection management via
+ * {@link Destination#newConnection()}.
+ */
public interface Connection extends AutoCloseable
{
+ /**
+ * Sends a request with an associated response listener.
+ *
+ * {@link Request#send(Response.Listener)} will eventually call this method to send the request.
+ * It is exposed to allow applications to send requests via unpooled connections.
+ *
+ * @param request the request to send
+ * @param listener the response listener
+ */
void send(Request request, Response.Listener listener);
@Override
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/api/ContentDecoder.java b/jetty-client/src/main/java/org/eclipse/jetty/client/api/ContentDecoder.java
index 656f490e0aa..b8dc313e7a0 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/api/ContentDecoder.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/api/ContentDecoder.java
@@ -18,6 +18,7 @@
package org.eclipse.jetty.client.api;
-public interface ContentDecoder
+// TODO
+interface ContentDecoder
{
}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/api/ContentProvider.java b/jetty-client/src/main/java/org/eclipse/jetty/client/api/ContentProvider.java
index 0be40d0c1fc..68d626e0056 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/api/ContentProvider.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/api/ContentProvider.java
@@ -20,7 +20,21 @@ package org.eclipse.jetty.client.api;
import java.nio.ByteBuffer;
+import org.eclipse.jetty.client.util.ByteBufferContentProvider;
+import org.eclipse.jetty.client.util.PathContentProvider;
+
+/**
+ * {@link ContentProvider} provides a repeatable source of request content.
+ *
+ * Implementations should return a new "view" over the same content every time {@link #iterator()} is invoked.
+ *
+ * Applications should rely on utility classes such as {@link ByteBufferContentProvider}
+ * or {@link PathContentProvider}.
+ */
public interface ContentProvider extends Iterable
{
+ /**
+ * @return the content length, if known, or -1 if the content length is unknown
+ */
long length();
}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/api/ContentResponse.java b/jetty-client/src/main/java/org/eclipse/jetty/client/api/ContentResponse.java
index 0be9edfe8e4..f960db2dfe6 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/api/ContentResponse.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/api/ContentResponse.java
@@ -18,7 +18,13 @@
package org.eclipse.jetty.client.api;
+/**
+ * A specialized {@link Response} that can hold a limited content in memory.
+ */
public interface ContentResponse extends Response
{
+ /**
+ * @return the response content
+ */
byte[] content();
}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/api/CookieStore.java b/jetty-client/src/main/java/org/eclipse/jetty/client/api/CookieStore.java
index 6aa77072c78..7ac798c58b6 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/api/CookieStore.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/api/CookieStore.java
@@ -20,13 +20,39 @@ package org.eclipse.jetty.client.api;
import java.util.List;
+import org.eclipse.jetty.client.HttpClient;
import org.eclipse.jetty.http.HttpCookie;
+/**
+ * A store for HTTP cookies that offers methods to match cookies for a given destination and path.
+ *
+ * @see HttpClient#getCookieStore()
+ */
public interface CookieStore
{
- List getCookies(Destination destination, String path);
+ /**
+ * Returns the non-expired cookies that match the given destination and path,
+ * recursively matching parent paths (for the same domain) and parent domains
+ * (for the root path).
+ *
+ * @param destination the destination representing the domain
+ * @param path the request path
+ * @return the list of matching cookies
+ */
+ List findCookies(Destination destination, String path);
+ /**
+ * Adds the given cookie to this store for the given destination.
+ * If the cookie's domain and the destination host do not match, the cookie is not added.
+ *
+ * @param destination the destination the cookie should belong to
+ * @param cookie the cookie to add
+ * @return whether the cookie has been added or not
+ */
boolean addCookie(Destination destination, HttpCookie cookie);
+ /**
+ * Removes all the cookies from this store.
+ */
void clear();
}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/api/Destination.java b/jetty-client/src/main/java/org/eclipse/jetty/client/api/Destination.java
index 2ec5a765e2d..3ed6524699c 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/api/Destination.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/api/Destination.java
@@ -20,15 +20,36 @@ package org.eclipse.jetty.client.api;
import java.util.concurrent.Future;
+import org.eclipse.jetty.client.HttpClient;
+
+/**
+ * {@link Destination} represents the triple made of the {@link #scheme()}, the {@link #host()}
+ * and the {@link #port()}.
+ *
+ * {@link Destination} holds a pool of {@link Connection}s, but allows to create unpooled
+ * connections if the application wants full control over connection management via {@link #newConnection()}.
+ *
+ * {@link Destination}s may be obtained via {@link HttpClient#getDestination(String, String, int)}
+ */
public interface Destination
{
+ /**
+ * @return the scheme of this destination, such as "http" or "https"
+ */
String scheme();
+ /**
+ * @return the host of this destination, such as "127.0.0.1" or "google.com"
+ */
String host();
+ /**
+ * @return the port of this destination such as 80 or 443
+ */
int port();
+ /**
+ * @return a future to a new, unpooled, {@link Connection}
+ */
Future newConnection();
-
- void send(Request request, Response.Listener listener);
}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/api/Request.java b/jetty-client/src/main/java/org/eclipse/jetty/client/api/Request.java
index 6b0f5a300dc..9fbb1373883 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/api/Request.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/api/Request.java
@@ -22,88 +22,274 @@ import java.io.IOException;
import java.nio.file.Path;
import java.util.concurrent.Future;
+import org.eclipse.jetty.client.HttpClient;
+import org.eclipse.jetty.client.util.StreamingResponseListener;
import org.eclipse.jetty.http.HttpFields;
import org.eclipse.jetty.http.HttpMethod;
import org.eclipse.jetty.http.HttpVersion;
import org.eclipse.jetty.util.Fields;
+/**
+ * {@link Request} represents a HTTP request, and offers a fluent interface to customize
+ * various attributes such as the path, the headers, the content, etc.
+ * You can create {@link Request} objects via {@link HttpClient#newRequest(String)} and
+ * you can send them using either {@link #send()} for a blocking semantic, or
+ * {@link #send(Response.Listener)} for an asynchronous semantic.
+ *
+ * @see Response
+ */
public interface Request
{
+ /**
+ * @return the conversation id
+ */
long id();
+ /**
+ * @return the scheme of this request, such as "http" or "https"
+ */
String scheme();
+ /**
+ * @param scheme the scheme of this request, such as "http" or "https"
+ * @return this request object
+ */
Request scheme(String scheme);
+ /**
+ * @return the host of this request, such as "127.0.0.1" or "google.com"
+ */
String host();
+ /**
+ * @return the port of this request such as 80 or 443
+ */
int port();
+ /**
+ * @return the method of this request, such as GET or POST
+ */
HttpMethod method();
+ /**
+ * @param method the method of this request, such as GET or POST
+ * @return this request object
+ */
Request method(HttpMethod method);
+ /**
+ * @return the path of this request, such as "/"
+ */
String path();
+ /**
+ * @param path the path of this request, such as "/"
+ * @return this request object
+ */
Request path(String path);
+ /**
+ * @return the full URI of this request such as "http://host:port/path"
+ */
String uri();
+ /**
+ * @return the HTTP version of this request, such as "HTTP/1.1"
+ */
HttpVersion version();
+ /**
+ * @param version the HTTP version of this request, such as "HTTP/1.1"
+ * @return this request object
+ */
Request version(HttpVersion version);
+ /**
+ * @return the query parameters of this request
+ */
Fields params();
+ /**
+ * @param name the name of the query parameter
+ * @param value the value of the query parameter
+ * @return this request object
+ */
Request param(String name, String value);
+ /**
+ * @return the headers of this request
+ */
HttpFields headers();
+ /**
+ * @param name the name of the header
+ * @param value the value of the header
+ * @return this request object
+ */
Request header(String name, String value);
+ /**
+ * @return the content provider of this request
+ */
ContentProvider content();
- Request content(ContentProvider buffer);
+ /**
+ * @param content the content provider of this request
+ * @return this request object
+ */
+ Request content(ContentProvider content);
+ /**
+ * Shortcut method to specify a file as a content for this request, with the default content type of
+ * "application/octect-stream".
+ *
+ * @param file the file to upload
+ * @return this request object
+ * @throws IOException if the file does not exist or cannot be read
+ */
Request file(Path file) throws IOException;
+ /**
+ * Shortcut method to specify a file as a content for this request, with the given content type.
+ *
+ * @param file the file to upload
+ * @param contentType the content type of the file
+ * @return this request object
+ * @throws IOException if the file does not exist or cannot be read
+ */
Request file(Path file, String contentType) throws IOException;
- Request decoder(ContentDecoder decoder);
+// Request decoder(ContentDecoder decoder);
+ /**
+ * @return the user agent for this request
+ */
String agent();
- Request agent(String userAgent);
+ /**
+ * @param agent the user agent for this request
+ * @return this request object
+ */
+ Request agent(String agent);
+ /**
+ * @return the idle timeout for this request
+ */
long idleTimeout();
+ /**
+ * @param timeout the idle timeout for this request
+ * @return this request object
+ */
Request idleTimeout(long timeout);
+ /**
+ * @return whether this request follows redirects
+ */
+ boolean followRedirects();
+
+ /**
+ * @param follow whether this request follows redirects
+ * @return this request object
+ */
Request followRedirects(boolean follow);
+ /**
+ * @return the listener for request events
+ */
Listener listener();
+ /**
+ * @param listener the listener for request events
+ * @return this request object
+ */
Request listener(Listener listener);
+ /**
+ * Sends this request and returns a {@link Future} that can be used to wait for the
+ * request and the response to be completed (either with a success or a failure).
+ *
+ * This method should be used when a simple blocking semantic is needed, and when it is known
+ * that the response content can be buffered without exceeding memory constraints.
+ * For example, this method is not appropriate to download big files from a server; consider using
+ * {@link #send(Response.Listener)} instead, passing your own {@link Response.Listener} or a utility
+ * listener such as {@link StreamingResponseListener}.
+ *
+ * The future will return when {@link Response.Listener#onComplete(Result)} is invoked.
+ *
+ * @return a {@link Future} to wait on for request and response completion
+ * @see Response.Listener#onComplete(Result)
+ */
Future send();
+ /**
+ * Sends this request and asynchronously notifies the given listener for response events.
+ *
+ * This method should be used when the application needs to be notified of the various response events
+ * as they happen, or when the application needs to efficiently manage the response content.
+ *
+ * @param listener the listener that receives response events
+ */
void send(Response.Listener listener);
+ /**
+ * Attempts to abort the send of this request.
+ *
+ * @see #aborted()
+ */
+ void abort();
+
+ /**
+ * @return whether {@link #abort()} was called
+ */
+ boolean aborted();
+
+ /**
+ * Listener for request events
+ */
public interface Listener
{
+ /**
+ * Callback method invoked when the request is queued, waiting to be sent
+ *
+ * @param request the request being queued
+ */
public void onQueued(Request request);
+ /**
+ * Callback method invoked when the request begins being processed in order to be sent.
+ * This is the last opportunity to modify the request.
+ *
+ * @param request the request that begins being processed
+ */
public void onBegin(Request request);
+ /**
+ * Callback method invoked when the request headers (and perhaps small content) have been sent.
+ * The request is now committed, and in transit to the server, and further modifications to the
+ * request may have no effect.
+ * @param request the request that has been committed
+ */
public void onHeaders(Request request);
- public void onFlush(Request request, int bytes);
-
+ /**
+ * Callback method invoked when the request has been successfully sent.
+ *
+ * @param request the request sent
+ */
public void onSuccess(Request request);
+ /**
+ * Callback method invoked when the request has failed to be sent
+ * @param request the request that failed
+ * @param failure the failure
+ */
public void onFailure(Request request, Throwable failure);
- public static class Adapter implements Listener
+ /**
+ * An empty implementation of {@link Listener}
+ */
+ public static class Empty implements Listener
{
@Override
public void onQueued(Request request)
@@ -120,11 +306,6 @@ public interface Request
{
}
- @Override
- public void onFlush(Request request, int bytes)
- {
- }
-
@Override
public void onSuccess(Request request)
{
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/api/Response.java b/jetty-client/src/main/java/org/eclipse/jetty/client/api/Response.java
index f4caa38f08f..79e09752b3d 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/api/Response.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/api/Response.java
@@ -20,38 +20,118 @@ package org.eclipse.jetty.client.api;
import java.nio.ByteBuffer;
+import org.eclipse.jetty.client.util.BufferingResponseListener;
import org.eclipse.jetty.http.HttpFields;
import org.eclipse.jetty.http.HttpVersion;
+/**
+ * {@link Response} represents a HTTP response and offers methods to retrieve status code, HTTP version
+ * and headers.
+ * {@link Response} objects are passed as parameters to {@link Response.Listener} callbacks, or as
+ * future result of {@link Request#send()}.
+ * {@link Response} objects do not contain getters for the response content, because it may be too large
+ * to fit into memory.
+ * The response content should be retrieved via {@link Response.Listener#onContent(Response, ByteBuffer) content
+ * events}, or via utility classes such as {@link BufferingResponseListener}.
+ */
public interface Response
{
+ /**
+ * @return the response listener passed to {@link Request#send(Listener)}
+ */
Listener listener();
+ /**
+ * @return the HTTP version of this response, such as "HTTP/1.1"
+ */
HttpVersion version();
+ /**
+ * @return the HTTP status code of this response, such as 200 or 404
+ */
int status();
+ /**
+ * @return the HTTP reason associated to the {@link #status()}
+ */
String reason();
+ /**
+ * @return the headers of this response
+ */
HttpFields headers();
+ /**
+ * Attempts to abort the send of this request.
+ */
void abort();
+ /**
+ * Listener for response events
+ */
public interface Listener
{
+ /**
+ * Callback method invoked when the response line containing HTTP version,
+ * HTTP status code and reason has been received and parsed.
+ *
+ * This method is the best approximation to detect when the first bytes of the response arrived to the client.
+ *
+ * @param response the response containing the response line data
+ */
public void onBegin(Response response);
+ /**
+ * Callback method invoked when the response headers have been received and parsed.
+ *
+ * @param response the response containing the response line data and the headers
+ */
public void onHeaders(Response response);
+ /**
+ * Callback method invoked when the response content has been received.
+ * This method may be invoked multiple times, and the {@code content} buffer must be consumed
+ * before returning from this method.
+ *
+ * @param response the response containing the response line data and the headers
+ * @param content the content bytes received
+ */
public void onContent(Response response, ByteBuffer content);
+ /**
+ * Callback method invoked when the whole response has been successfully received.
+ *
+ * @param response the response containing the response line data and the headers
+ */
public void onSuccess(Response response);
+ /**
+ * Callback method invoked when the response has failed in the process of being received
+ *
+ * @param response the response containing data up to the point the failure happened
+ * @param failure the failure happened
+ */
public void onFailure(Response response, Throwable failure);
+ /**
+ * Callback method invoked when the request and the response have been processed,
+ * either successfully or not.
+ *
+ * The {@code result} parameter contains the request, the response, and eventual failures.
+ *
+ * Requests may complete after response, for example in case of big uploads that are
+ * discarded or read asynchronously by the server.
+ * This method is always invoked after {@link #onSuccess(Response)} or
+ * {@link #onFailure(Response, Throwable)}, and only when request indicates that it is completed.
+ *
+ * @param result the result of the request / response exchange
+ */
public void onComplete(Result result);
- public static class Adapter implements Listener
+ /**
+ * An empty implementation of {@link Listener}
+ */
+ public static class Empty implements Listener
{
@Override
public void onBegin(Response response)
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/api/Result.java b/jetty-client/src/main/java/org/eclipse/jetty/client/api/Result.java
index ff59d9e2cf0..8ad009354a3 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/api/Result.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/api/Result.java
@@ -18,6 +18,10 @@
package org.eclipse.jetty.client.api;
+/**
+ * The result of a request / response exchange, containing the {@link Request}, the {@link Response}
+ * and eventual failures of either.
+ */
public class Result
{
private final Request request;
@@ -48,21 +52,49 @@ public class Result
this.responseFailure = responseFailure;
}
+ /**
+ * @return the request object
+ */
public Request getRequest()
{
return request;
}
+ /**
+ * @return the request failure, if any
+ */
+ public Throwable getRequestFailure()
+ {
+ return requestFailure;
+ }
+
+ /**
+ * @return the response object
+ */
public Response getResponse()
{
return response;
}
+ /**
+ * @return the response failure, if any
+ */
+ public Throwable getResponseFailure()
+ {
+ return responseFailure;
+ }
+
+ /**
+ * @return whether either the response or the request failed
+ */
public boolean isFailed()
{
return getFailure() != null;
}
+ /**
+ * @return the response failure, if any, otherwise the request failure, if any
+ */
public Throwable getFailure()
{
return responseFailure != null ? responseFailure : requestFailure;
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/package-info.java b/jetty-client/src/main/java/org/eclipse/jetty/client/package-info.java
new file mode 100644
index 00000000000..3e4c1890950
--- /dev/null
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/package-info.java
@@ -0,0 +1,50 @@
+//
+// ========================================================================
+// Copyright (c) 1995-2012 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.
+// ========================================================================
+//
+
+/**
+ * This package provides APIs, utility classes and implementation class of an asynchronous HTTP client
+ *
+ * The core class is {@link HttpClient}, which acts as a central configuration object (for example
+ * for {@link HttpClient#setIdleTimeout(long) idle timeouts}, {@link HttpClient#setMaxConnectionsPerAddress(int)
+ * max connections per domain}, etc.) and as a factory for {@link Request} objects.
+ *
+ * The HTTP protocol is based on the request/response paradigm, a unit that in this implementation is called
+ * exchange and is represented by {@link HttpExchange}.
+ * An initial request may trigger a sequence of exchanges with one or more servers, called a conversation
+ * and represented by {@link HttpConversation}. A typical example of a conversation is a redirect, where
+ * upon a request for a resource URI, the server replies with a redirect (for example with the 303 status code)
+ * to another URI. This conversation is made of a first exchange made of the original request and its 303 response,
+ * and of a second exchange made of the request for the new URI and its 200 response.
+ *
+ * {@link HttpClient} holds a number of {@link HttpDestination destinations}, which in turn hold a number of
+ * pooled {@link HttpConnection connections}.
+ *
+ * When a request is sent, its exchange is associated to a connection, either taken from an idle queue or created
+ * anew, and when both the request and response are completed, the exchange is disassociated from the connection.
+ * Conversation may span multiple connections on different destinations, and therefore are maintained at the
+ * {@link HttpClient} level.
+ *
+ * Applications may decide to send the request and wait for the response in a blocking way, using
+ * {@link Request#send()}.
+ * Alternatively, application may ask to be notified of response events asynchronously, using
+ * {@link Request#send(Response.Listener)}.
+ */
+package org.eclipse.jetty.client;
+
+import org.eclipse.jetty.client.api.Request;
+import org.eclipse.jetty.client.api.Response;
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/util/BasicAuthentication.java b/jetty-client/src/main/java/org/eclipse/jetty/client/util/BasicAuthentication.java
index 8d77d71f390..640b98f1c04 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/util/BasicAuthentication.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/util/BasicAuthentication.java
@@ -22,8 +22,10 @@ import java.io.UnsupportedEncodingException;
import java.nio.charset.UnsupportedCharsetException;
import org.eclipse.jetty.client.api.Authentication;
+import org.eclipse.jetty.client.api.ContentResponse;
import org.eclipse.jetty.client.api.Request;
import org.eclipse.jetty.http.HttpHeader;
+import org.eclipse.jetty.util.Attributes;
import org.eclipse.jetty.util.B64Code;
import org.eclipse.jetty.util.StringUtil;
@@ -55,17 +57,48 @@ public class BasicAuthentication implements Authentication
}
@Override
- public void authenticate(Request request)
+ public Result authenticate(Request request, ContentResponse response, String wwwAuthenticate, Attributes context)
{
String encoding = StringUtil.__ISO_8859_1;
try
{
String value = "Basic " + B64Code.encode(user + ":" + password, encoding);
- request.header(HttpHeader.AUTHORIZATION.asString(), value);
+ return new BasicResult(request.uri(), value);
}
catch (UnsupportedEncodingException x)
{
throw new UnsupportedCharsetException(encoding);
}
}
+
+ private static class BasicResult implements Result
+ {
+ private final String uri;
+ private final String value;
+
+ public BasicResult(String uri, String value)
+ {
+ this.uri = uri;
+ this.value = value;
+ }
+
+ @Override
+ public String getURI()
+ {
+ return uri;
+ }
+
+ @Override
+ public void apply(Request request)
+ {
+ if (request.uri().startsWith(uri))
+ request.header(HttpHeader.AUTHORIZATION.asString(), value);
+ }
+
+ @Override
+ public String toString()
+ {
+ return String.format("Basic authentication result for %s", uri);
+ }
+ }
}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/util/BlockingResponseListener.java b/jetty-client/src/main/java/org/eclipse/jetty/client/util/BlockingResponseListener.java
new file mode 100644
index 00000000000..39d619782af
--- /dev/null
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/util/BlockingResponseListener.java
@@ -0,0 +1,117 @@
+//
+// ========================================================================
+// Copyright (c) 1995-2012 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.client.util;
+
+import java.nio.ByteBuffer;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.eclipse.jetty.client.HttpContentResponse;
+import org.eclipse.jetty.client.api.ContentResponse;
+import org.eclipse.jetty.client.api.Response;
+import org.eclipse.jetty.client.api.Result;
+
+public class BlockingResponseListener extends BufferingResponseListener implements Future
+{
+ private final CountDownLatch latch = new CountDownLatch(1);
+ private ContentResponse response;
+ private Throwable failure;
+ private volatile boolean cancelled;
+
+ @Override
+ public void onBegin(Response response)
+ {
+ super.onBegin(response);
+ if (cancelled)
+ response.abort();
+ }
+
+ @Override
+ public void onHeaders(Response response)
+ {
+ super.onHeaders(response);
+ if (cancelled)
+ response.abort();
+ }
+
+ @Override
+ public void onContent(Response response, ByteBuffer content)
+ {
+ super.onContent(response, content);
+ if (cancelled)
+ response.abort();
+ }
+
+ @Override
+ public void onComplete(Result result)
+ {
+ super.onComplete(result);
+ response = new HttpContentResponse(result.getResponse(), getContent());
+ failure = result.getFailure();
+ latch.countDown();
+ }
+
+ @Override
+ public boolean cancel(boolean mayInterruptIfRunning)
+ {
+ cancelled = true;
+ return latch.getCount() == 0;
+ }
+
+ @Override
+ public boolean isCancelled()
+ {
+ return cancelled;
+ }
+
+ @Override
+ public boolean isDone()
+ {
+ return latch.getCount() == 0 || isCancelled();
+ }
+
+ @Override
+ public ContentResponse get() throws InterruptedException, ExecutionException
+ {
+ latch.await();
+ return result();
+ }
+
+ @Override
+ public ContentResponse get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException
+ {
+ boolean expired = !latch.await(timeout, unit);
+ if (expired)
+ throw new TimeoutException();
+ return result();
+ }
+
+ private ContentResponse result() throws ExecutionException
+ {
+ if (isCancelled())
+ throw (CancellationException)new CancellationException().initCause(failure);
+ if (failure != null)
+ throw new ExecutionException(failure);
+ return response;
+ }
+}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/util/BufferingResponseListener.java b/jetty-client/src/main/java/org/eclipse/jetty/client/util/BufferingResponseListener.java
index 0db2571ff23..04e426a2cb1 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/util/BufferingResponseListener.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/util/BufferingResponseListener.java
@@ -18,38 +18,32 @@
package org.eclipse.jetty.client.util;
+import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
-import java.nio.charset.Charset;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
+import java.nio.charset.UnsupportedCharsetException;
import org.eclipse.jetty.client.api.Response;
-public class BufferingResponseListener extends Response.Listener.Adapter
+public class BufferingResponseListener extends Response.Listener.Empty
{
- private final CountDownLatch latch = new CountDownLatch(1);
- private final int maxCapacity;
- private Response response;
- private Throwable failure;
- private byte[] buffer = new byte[0];
+ private final int maxLength;
+ private volatile byte[] buffer = new byte[0];
public BufferingResponseListener()
{
- this(16 * 1024 * 1024);
+ this(2 * 1024 * 1024);
}
- public BufferingResponseListener(int maxCapacity)
+ public BufferingResponseListener(int maxLength)
{
- this.maxCapacity = maxCapacity;
+ this.maxLength = maxLength;
}
@Override
public void onContent(Response response, ByteBuffer content)
{
long newLength = buffer.length + content.remaining();
- if (newLength > maxCapacity)
+ if (newLength > maxLength)
throw new IllegalStateException("Buffering capacity exceeded");
byte[] newBuffer = new byte[(int)newLength];
@@ -58,38 +52,20 @@ public class BufferingResponseListener extends Response.Listener.Adapter
buffer = newBuffer;
}
- @Override
- public void onSuccess(Response response)
- {
- this.response = response;
- latch.countDown();
- }
-
- @Override
- public void onFailure(Response response, Throwable failure)
- {
- this.response = response;
- this.failure = failure;
- latch.countDown();
- }
-
- public Response await(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException
- {
- boolean expired = !latch.await(timeout, unit);
- if (failure != null)
- throw new ExecutionException(failure);
- if (expired)
- throw new TimeoutException();
- return response;
- }
-
- public byte[] content()
+ public byte[] getContent()
{
return buffer;
}
- public String contentAsString(String encoding)
+ public String getContent(String encoding)
{
- return new String(content(), Charset.forName(encoding));
+ try
+ {
+ return new String(getContent(), encoding);
+ }
+ catch (UnsupportedEncodingException x)
+ {
+ throw new UnsupportedCharsetException(encoding);
+ }
}
}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/util/DigestAuthentication.java b/jetty-client/src/main/java/org/eclipse/jetty/client/util/DigestAuthentication.java
new file mode 100644
index 00000000000..b21d46213d8
--- /dev/null
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/util/DigestAuthentication.java
@@ -0,0 +1,271 @@
+//
+// ========================================================================
+// Copyright (c) 1995-2012 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.client.util;
+
+import java.nio.charset.Charset;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.eclipse.jetty.client.api.Authentication;
+import org.eclipse.jetty.client.api.ContentResponse;
+import org.eclipse.jetty.client.api.Request;
+import org.eclipse.jetty.http.HttpHeader;
+import org.eclipse.jetty.util.Attributes;
+import org.eclipse.jetty.util.TypeUtil;
+
+public class DigestAuthentication implements Authentication
+{
+ private static final Pattern PARAM_PATTERN = Pattern.compile("([^=]+)=(.*)");
+
+ private final String uri;
+ private final String realm;
+ private final String user;
+ private final String password;
+
+ public DigestAuthentication(String uri, String realm, String user, String password)
+ {
+ this.uri = uri;
+ this.realm = realm;
+ this.user = user;
+ this.password = password;
+ }
+
+ @Override
+ public boolean matches(String type, String uri, String realm)
+ {
+ if (!"digest".equalsIgnoreCase(type))
+ return false;
+
+ if (!uri.startsWith(this.uri))
+ return false;
+
+ return this.realm.equals(realm);
+ }
+
+ @Override
+ public Result authenticate(Request request, ContentResponse response, String wwwAuthenticate, Attributes context)
+ {
+ // Avoid case sensitivity problems on the 'D' character
+ String type = "igest";
+ wwwAuthenticate = wwwAuthenticate.substring(wwwAuthenticate.indexOf(type) + type.length());
+
+ Map params = parseParams(wwwAuthenticate);
+ String nonce = params.get("nonce");
+ if (nonce == null || nonce.length() == 0)
+ return null;
+ String opaque = params.get("opaque");
+ String algorithm = params.get("algorithm");
+ if (algorithm == null)
+ algorithm = "MD5";
+ MessageDigest digester = getMessageDigest(algorithm);
+ if (digester == null)
+ return null;
+ String serverQOP = params.get("qop");
+ String clientQOP = null;
+ if (serverQOP != null)
+ {
+ List serverQOPValues = Arrays.asList(serverQOP.split(","));
+ if (serverQOPValues.contains("auth"))
+ clientQOP = "auth";
+ else if (serverQOPValues.contains("auth-int"))
+ clientQOP = "auth-int";
+ }
+
+ return new DigestResult(request.uri(), response.content(), realm, user, password, algorithm, nonce, clientQOP, opaque);
+ }
+
+ private Map parseParams(String wwwAuthenticate)
+ {
+ Map result = new HashMap<>();
+ List parts = splitParams(wwwAuthenticate);
+ for (String part : parts)
+ {
+ Matcher matcher = PARAM_PATTERN.matcher(part);
+ if (matcher.matches())
+ {
+ String name = matcher.group(1).trim().toLowerCase();
+ String value = matcher.group(2).trim();
+ if (value.startsWith("\"") && value.endsWith("\""))
+ value = value.substring(1, value.length() - 1);
+ result.put(name, value);
+ }
+ }
+ return result;
+ }
+
+ private List splitParams(String paramString)
+ {
+ List result = new ArrayList<>();
+ int start = 0;
+ for (int i = 0; i < paramString.length(); ++i)
+ {
+ int quotes = 0;
+ char ch = paramString.charAt(i);
+ switch (ch)
+ {
+ case '\\':
+ ++i;
+ break;
+ case '"':
+ ++quotes;
+ break;
+ case ',':
+ if (quotes % 2 == 0)
+ {
+ result.add(paramString.substring(start, i).trim());
+ start = i + 1;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ result.add(paramString.substring(start, paramString.length()).trim());
+ return result;
+ }
+
+ private MessageDigest getMessageDigest(String algorithm)
+ {
+ try
+ {
+ return MessageDigest.getInstance(algorithm);
+ }
+ catch (NoSuchAlgorithmException x)
+ {
+ return null;
+ }
+ }
+
+ private class DigestResult implements Result
+ {
+ private final AtomicInteger nonceCount = new AtomicInteger();
+ private final String uri;
+ private final byte[] content;
+ private final String realm;
+ private final String user;
+ private final String password;
+ private final String algorithm;
+ private final String nonce;
+ private final String qop;
+ private final String opaque;
+
+ public DigestResult(String uri, byte[] content, String realm, String user, String password, String algorithm, String nonce, String qop, String opaque)
+ {
+ this.uri = uri;
+ this.content = content;
+ this.realm = realm;
+ this.user = user;
+ this.password = password;
+ this.algorithm = algorithm;
+ this.nonce = nonce;
+ this.qop = qop;
+ this.opaque = opaque;
+ }
+
+ @Override
+ public String getURI()
+ {
+ return uri;
+ }
+
+ @Override
+ public void apply(Request request)
+ {
+ if (!request.uri().startsWith(uri))
+ return;
+
+ MessageDigest digester = getMessageDigest(algorithm);
+ if (digester == null)
+ return;
+
+ Charset charset = Charset.forName("ISO-8859-1");
+ String A1 = user + ":" + realm + ":" + password;
+ String hashA1 = toHexString(digester.digest(A1.getBytes(charset)));
+
+ String A2 = request.method().asString() + ":" + request.uri();
+ if ("auth-int".equals(qop))
+ A2 += ":" + toHexString(digester.digest(content));
+ String hashA2 = toHexString(digester.digest(A2.getBytes(charset)));
+
+ String nonceCount;
+ String clientNonce;
+ String A3;
+ if (qop != null)
+ {
+ nonceCount = nextNonceCount();
+ clientNonce = newClientNonce();
+ A3 = hashA1 + ":" + nonce + ":" + nonceCount + ":" + clientNonce + ":" + qop + ":" + hashA2;
+ }
+ else
+ {
+ nonceCount = null;
+ clientNonce = null;
+ A3 = hashA1 + ":" + nonce + ":" + hashA2;
+ }
+ String hashA3 = toHexString(digester.digest(A3.getBytes(charset)));
+
+ StringBuilder value = new StringBuilder("Digest");
+ value.append(" username=\"").append(user).append("\"");
+ value.append(", realm=\"").append(realm).append("\"");
+ value.append(", nonce=\"").append(nonce).append("\"");
+ if (opaque != null)
+ value.append(", opaque=\"").append(opaque).append("\"");
+ value.append(", algorithm=\"").append(algorithm).append("\"");
+ value.append(", uri=\"").append(request.uri()).append("\"");
+ if (qop != null)
+ {
+ value.append(", qop=\"").append(qop).append("\"");
+ value.append(", nc=\"").append(nonceCount).append("\"");
+ value.append(", cnonce=\"").append(clientNonce).append("\"");
+ }
+ value.append(", response=\"").append(hashA3).append("\"");
+
+ request.header(HttpHeader.AUTHORIZATION.asString(), value.toString());
+ }
+
+ private String nextNonceCount()
+ {
+ String padding = "00000000";
+ String next = Integer.toHexString(nonceCount.incrementAndGet()).toLowerCase();
+ return padding.substring(0, padding.length() - next.length()) + next;
+ }
+
+ private String newClientNonce()
+ {
+ Random random = new Random();
+ byte[] bytes = new byte[8];
+ random.nextBytes(bytes);
+ return toHexString(bytes);
+ }
+
+ private String toHexString(byte[] bytes)
+ {
+ return TypeUtil.toHexString(bytes).toLowerCase();
+ }
+ }
+}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/util/StreamingResponseListener.java b/jetty-client/src/main/java/org/eclipse/jetty/client/util/StreamingResponseListener.java
index 1337c1d0e48..e0402b01284 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/util/StreamingResponseListener.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/util/StreamingResponseListener.java
@@ -24,7 +24,7 @@ import java.util.concurrent.TimeUnit;
import org.eclipse.jetty.client.api.Response;
-public class StreamingResponseListener extends Response.Listener.Adapter
+public class StreamingResponseListener extends Response.Listener.Empty
{
public Response get(long timeout, TimeUnit seconds)
{
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/AbstractHttpClientServerTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/AbstractHttpClientServerTest.java
index 4aeeabad4d6..48ce8e3efa7 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/AbstractHttpClientServerTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/AbstractHttpClientServerTest.java
@@ -49,7 +49,8 @@ public class AbstractHttpClientServerTest
public void start(Handler handler) throws Exception
{
- server = new Server();
+ if (server == null)
+ server = new Server();
connector = new SelectChannelConnector(server);
server.addConnector(connector);
server.setHandler(handler);
@@ -62,11 +63,12 @@ public class AbstractHttpClientServerTest
}
@After
- public void destroy() throws Exception
+ public void dispose() throws Exception
{
if (client != null)
client.stop();
if (server != null)
server.stop();
+ server = null;
}
}
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/EmptyHandler.java b/jetty-client/src/test/java/org/eclipse/jetty/client/EmptyServerHandler.java
similarity index 95%
rename from jetty-client/src/test/java/org/eclipse/jetty/client/EmptyHandler.java
rename to jetty-client/src/test/java/org/eclipse/jetty/client/EmptyServerHandler.java
index bfedac1c5a7..d5af3dd9534 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/EmptyHandler.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/EmptyServerHandler.java
@@ -26,7 +26,7 @@ import javax.servlet.http.HttpServletResponse;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.handler.AbstractHandler;
-public class EmptyHandler extends AbstractHandler
+public class EmptyServerHandler extends AbstractHandler
{
@Override
public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientAuthenticationTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientAuthenticationTest.java
index 77ed14f2e35..7a06dca80c5 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientAuthenticationTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientAuthenticationTest.java
@@ -18,36 +18,90 @@
package org.eclipse.jetty.client;
-import java.io.IOException;
+import java.io.File;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
-import javax.servlet.ServletException;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import org.eclipse.jetty.client.api.Authentication;
import org.eclipse.jetty.client.api.AuthenticationStore;
import org.eclipse.jetty.client.api.ContentResponse;
import org.eclipse.jetty.client.api.Request;
import org.eclipse.jetty.client.util.BasicAuthentication;
+import org.eclipse.jetty.client.util.DigestAuthentication;
import org.eclipse.jetty.http.HttpHeader;
-import org.eclipse.jetty.server.handler.AbstractHandler;
-import org.eclipse.jetty.util.B64Code;
-import org.eclipse.jetty.util.IO;
+import org.eclipse.jetty.security.Authenticator;
+import org.eclipse.jetty.security.ConstraintMapping;
+import org.eclipse.jetty.security.ConstraintSecurityHandler;
+import org.eclipse.jetty.security.HashLoginService;
+import org.eclipse.jetty.security.LoginService;
+import org.eclipse.jetty.security.authentication.BasicAuthenticator;
+import org.eclipse.jetty.security.authentication.DigestAuthenticator;
+import org.eclipse.jetty.server.Handler;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.toolchain.test.MavenTestingUtils;
+import org.eclipse.jetty.util.security.Constraint;
import org.junit.Assert;
import org.junit.Test;
public class HttpClientAuthenticationTest extends AbstractHttpClientServerTest
{
- @Test
- public void test_BasicAuthentication_WithChallenge() throws Exception
- {
- start(new BasicAuthenticationHandler());
+ private String realm = "TestRealm";
+ public void startBasic(Handler handler) throws Exception
+ {
+ start(new BasicAuthenticator(), handler);
+ }
+
+ public void startDigest(Handler handler) throws Exception
+ {
+ start(new DigestAuthenticator(), handler);
+ }
+
+ private void start(Authenticator authenticator, Handler handler) throws Exception
+ {
+ server = new Server();
+ File realmFile = MavenTestingUtils.getTestResourceFile("realm.properties");
+ LoginService loginService = new HashLoginService(realm, realmFile.getAbsolutePath());
+ server.addBean(loginService);
+
+ ConstraintSecurityHandler securityHandler = new ConstraintSecurityHandler();
+
+ Constraint constraint = new Constraint();
+ constraint.setAuthenticate(true);
+ constraint.setRoles(new String[]{"*"});
+ ConstraintMapping mapping = new ConstraintMapping();
+ mapping.setPathSpec("/*");
+ mapping.setConstraint(constraint);
+
+ securityHandler.addConstraintMapping(mapping);
+ securityHandler.setAuthenticator(authenticator);
+ securityHandler.setLoginService(loginService);
+ securityHandler.setStrict(false);
+
+ securityHandler.setHandler(handler);
+ start(securityHandler);
+ }
+
+ @Test
+ public void test_BasicAuthentication() throws Exception
+ {
+ startBasic(new EmptyServerHandler());
+ test_Authentication(new BasicAuthentication("http://localhost:" + connector.getLocalPort(), realm, "basic", "basic"));
+ }
+
+ @Test
+ public void test_DigestAuthentication() throws Exception
+ {
+ startDigest(new EmptyServerHandler());
+ test_Authentication(new DigestAuthentication("http://localhost:" + connector.getLocalPort(), realm, "digest", "digest"));
+ }
+
+ private void test_Authentication(Authentication authentication) throws Exception
+ {
AuthenticationStore authenticationStore = client.getAuthenticationStore();
- String realm = "test";
final AtomicInteger requests = new AtomicInteger();
- Request.Listener.Adapter requestListener = new Request.Listener.Adapter()
+ Request.Listener.Empty requestListener = new Request.Listener.Empty()
{
@Override
public void onSuccess(Request request)
@@ -58,10 +112,7 @@ public class HttpClientAuthenticationTest extends AbstractHttpClientServerTest
client.getRequestListeners().add(requestListener);
// Request without Authentication causes a 401
- Request request = client.newRequest("localhost", connector.getLocalPort())
- .path("/test")
- .param("type", "Basic")
- .param("realm", realm);
+ Request request = client.newRequest("localhost", connector.getLocalPort()).path("/test");
ContentResponse response = request.send().get(5, TimeUnit.SECONDS);
Assert.assertNotNull(response);
Assert.assertEquals(401, response.status());
@@ -69,11 +120,9 @@ public class HttpClientAuthenticationTest extends AbstractHttpClientServerTest
client.getRequestListeners().remove(requestListener);
requests.set(0);
- String user = "jetty";
- String password = "rocks";
- authenticationStore.addAuthentication(new BasicAuthentication("http://localhost:" + connector.getLocalPort(), realm, user, password));
+ authenticationStore.addAuthentication(authentication);
- requestListener = new Request.Listener.Adapter()
+ requestListener = new Request.Listener.Empty()
{
@Override
public void onSuccess(Request request)
@@ -84,7 +133,6 @@ public class HttpClientAuthenticationTest extends AbstractHttpClientServerTest
client.getRequestListeners().add(requestListener);
// Request with authentication causes a 401 (no previous successful authentication) + 200
- request.param("user", user).param("password", password);
response = request.send().get(5, TimeUnit.SECONDS);
Assert.assertNotNull(response);
Assert.assertEquals(200, response.status());
@@ -92,7 +140,7 @@ public class HttpClientAuthenticationTest extends AbstractHttpClientServerTest
client.getRequestListeners().remove(requestListener);
requests.set(0);
- requestListener = new Request.Listener.Adapter()
+ requestListener = new Request.Listener.Empty()
{
@Override
public void onSuccess(Request request)
@@ -105,65 +153,11 @@ public class HttpClientAuthenticationTest extends AbstractHttpClientServerTest
// Further requests do not trigger 401 because there is a previous successful authentication
// Remove existing header to be sure it's added by the implementation
request.header(HttpHeader.AUTHORIZATION.asString(), null);
- response = request.send().get(555, TimeUnit.SECONDS);
+ response = request.send().get(5, TimeUnit.SECONDS);
Assert.assertNotNull(response);
Assert.assertEquals(200, response.status());
Assert.assertEquals(1, requests.get());
client.getRequestListeners().remove(requestListener);
requests.set(0);
}
-
- private class BasicAuthenticationHandler extends AbstractHandler
- {
- @Override
- public void handle(String target, org.eclipse.jetty.server.Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
- {
- try
- {
- String type = request.getParameter("type");
- String authorization = request.getHeader(HttpHeader.AUTHORIZATION.asString());
- if (authorization == null)
- {
- String realm = request.getParameter("realm");
- response.setStatus(401);
- switch (type)
- {
- case "Basic":
- {
- response.setHeader("WWW-Authenticate", "Basic realm=\"" + realm + "\"");
- break;
- }
- default:
- {
- throw new IllegalStateException();
- }
- }
- }
- else
- {
- switch (type)
- {
- case "Basic":
- {
- String user = request.getParameter("user");
- String password = request.getParameter("password");
- String expected = "Basic " + B64Code.encode(user + ":" + password);
- if (!expected.equals(authorization))
- throw new IOException(expected + " != " + authorization);
- IO.copy(request.getInputStream(), response.getOutputStream());
- break;
- }
- default:
- {
- throw new IllegalStateException();
- }
- }
- }
- }
- finally
- {
- baseRequest.setHandled(true);
- }
- }
- }
}
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientStreamTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientStreamTest.java
index 8ea31a6c67a..6bc17b34895 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientStreamTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientStreamTest.java
@@ -49,12 +49,12 @@ public class HttpClientStreamTest extends AbstractHttpClientServerTest
output.write(kb);
}
- start(new EmptyHandler());
+ start(new EmptyServerHandler());
final AtomicLong requestTime = new AtomicLong();
ContentResponse response = client.newRequest("localhost", connector.getLocalPort())
.file(upload)
- .listener(new Request.Listener.Adapter()
+ .listener(new Request.Listener.Empty()
{
@Override
public void onSuccess(Request request)
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientTest.java
index 8eb976960cc..e9380ef0eb1 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientTest.java
@@ -57,7 +57,7 @@ public class HttpClientTest extends AbstractHttpClientServerTest
@Test
public void testStoppingClosesConnections() throws Exception
{
- start(new EmptyHandler());
+ start(new EmptyServerHandler());
String scheme = "http";
String host = "localhost";
@@ -84,14 +84,14 @@ public class HttpClientTest extends AbstractHttpClientServerTest
Assert.assertEquals(0, client.getDestinations().size());
Assert.assertEquals(0, destination.getIdleConnections().size());
Assert.assertEquals(0, destination.getActiveConnections().size());
- Assert.assertEquals(0, client.getCookieStore().getCookies(destination, path).size());
+ Assert.assertEquals(0, client.getCookieStore().findCookies(destination, path).size());
Assert.assertFalse(connection.getEndPoint().isOpen());
}
@Test
public void test_DestinationCount() throws Exception
{
- start(new EmptyHandler());
+ start(new EmptyServerHandler());
String scheme = "http";
String host = "localhost";
@@ -111,7 +111,7 @@ public class HttpClientTest extends AbstractHttpClientServerTest
@Test
public void test_GET_ResponseWithoutContent() throws Exception
{
- start(new EmptyHandler());
+ start(new EmptyServerHandler());
Response response = client.GET("http://localhost:" + connector.getLocalPort()).get(5, TimeUnit.SECONDS);
@@ -212,14 +212,14 @@ public class HttpClientTest extends AbstractHttpClientServerTest
@Test
public void test_QueuedRequest_IsSent_WhenPreviousRequestSucceeded() throws Exception
{
- start(new EmptyHandler());
+ start(new EmptyServerHandler());
client.setMaxConnectionsPerAddress(1);
final CountDownLatch latch = new CountDownLatch(1);
final CountDownLatch successLatch = new CountDownLatch(2);
client.newRequest("http://localhost:" + connector.getLocalPort())
- .listener(new org.eclipse.jetty.client.api.Request.Listener.Adapter()
+ .listener(new org.eclipse.jetty.client.api.Request.Listener.Empty()
{
@Override
public void onBegin(org.eclipse.jetty.client.api.Request request)
@@ -234,7 +234,7 @@ public class HttpClientTest extends AbstractHttpClientServerTest
}
}
})
- .send(new Response.Listener.Adapter()
+ .send(new Response.Listener.Empty()
{
@Override
public void onSuccess(Response response)
@@ -245,7 +245,7 @@ public class HttpClientTest extends AbstractHttpClientServerTest
});
client.newRequest("http://localhost:" + connector.getLocalPort())
- .listener(new org.eclipse.jetty.client.api.Request.Listener.Adapter()
+ .listener(new org.eclipse.jetty.client.api.Request.Listener.Empty()
{
@Override
public void onQueued(org.eclipse.jetty.client.api.Request request)
@@ -253,7 +253,7 @@ public class HttpClientTest extends AbstractHttpClientServerTest
latch.countDown();
}
})
- .send(new Response.Listener.Adapter()
+ .send(new Response.Listener.Empty()
{
@Override
public void onSuccess(Response response)
@@ -270,7 +270,7 @@ public class HttpClientTest extends AbstractHttpClientServerTest
@Test
public void test_QueuedRequest_IsSent_WhenPreviousRequestClosedConnection() throws Exception
{
- start(new EmptyHandler());
+ start(new EmptyServerHandler());
client.setMaxConnectionsPerAddress(1);
final long idleTimeout = 1000;
@@ -278,7 +278,7 @@ public class HttpClientTest extends AbstractHttpClientServerTest
final CountDownLatch latch = new CountDownLatch(3);
client.newRequest("http://localhost:" + connector.getLocalPort())
- .listener(new org.eclipse.jetty.client.api.Request.Listener.Adapter()
+ .listener(new org.eclipse.jetty.client.api.Request.Listener.Empty()
{
@Override
public void onBegin(org.eclipse.jetty.client.api.Request request)
@@ -299,7 +299,7 @@ public class HttpClientTest extends AbstractHttpClientServerTest
latch.countDown();
}
})
- .send(new Response.Listener.Adapter()
+ .send(new Response.Listener.Empty()
{
@Override
public void onFailure(Response response, Throwable failure)
@@ -309,7 +309,7 @@ public class HttpClientTest extends AbstractHttpClientServerTest
});
client.newRequest("http://localhost:" + connector.getLocalPort())
- .send(new Response.Listener.Adapter()
+ .send(new Response.Listener.Empty()
{
@Override
public void onSuccess(Response response)
@@ -326,7 +326,7 @@ public class HttpClientTest extends AbstractHttpClientServerTest
@Test
public void test_ExchangeIsComplete_OnlyWhenBothRequestAndResponseAreComplete() throws Exception
{
- start(new EmptyHandler());
+ start(new EmptyServerHandler());
// Prepare a big file to upload
Path targetTestsDir = MavenTestingUtils.getTargetTestingDir().toPath();
@@ -345,7 +345,7 @@ public class HttpClientTest extends AbstractHttpClientServerTest
final AtomicLong responseTime = new AtomicLong();
client.newRequest("localhost", connector.getLocalPort())
.file(file)
- .listener(new org.eclipse.jetty.client.api.Request.Listener.Adapter()
+ .listener(new org.eclipse.jetty.client.api.Request.Listener.Empty()
{
@Override
public void onSuccess(org.eclipse.jetty.client.api.Request request)
@@ -354,7 +354,7 @@ public class HttpClientTest extends AbstractHttpClientServerTest
latch.countDown();
}
})
- .send(new Response.Listener.Adapter()
+ .send(new Response.Listener.Empty()
{
@Override
public void onSuccess(Response response)
@@ -414,7 +414,7 @@ public class HttpClientTest extends AbstractHttpClientServerTest
return Arrays.asList(ByteBuffer.allocate(chunkSize), null).iterator();
}
})
- .send(new Response.Listener.Adapter()
+ .send(new Response.Listener.Empty()
{
@Override
public void onComplete(Result result)
@@ -429,13 +429,13 @@ public class HttpClientTest extends AbstractHttpClientServerTest
@Test
public void test_ExchangeIsComplete_WhenRequestFails_WithNoResponse() throws Exception
{
- start(new EmptyHandler());
+ start(new EmptyServerHandler());
final CountDownLatch latch = new CountDownLatch(1);
final String host = "localhost";
final int port = connector.getLocalPort();
client.newRequest(host, port)
- .listener(new org.eclipse.jetty.client.api.Request.Listener.Adapter()
+ .listener(new org.eclipse.jetty.client.api.Request.Listener.Empty()
{
@Override
public void onBegin(org.eclipse.jetty.client.api.Request request)
@@ -444,7 +444,7 @@ public class HttpClientTest extends AbstractHttpClientServerTest
destination.getActiveConnections().peek().close();
}
})
- .send(new Response.Listener.Adapter()
+ .send(new Response.Listener.Empty()
{
@Override
public void onComplete(Result result)
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpConnectionLifecycleTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpConnectionLifecycleTest.java
index 19f97bdbb03..5746d4a6d16 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpConnectionLifecycleTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpConnectionLifecycleTest.java
@@ -42,7 +42,7 @@ public class HttpConnectionLifecycleTest extends AbstractHttpClientServerTest
@Test
public void test_SuccessfulRequest_ReturnsConnection() throws Exception
{
- start(new EmptyHandler());
+ start(new EmptyServerHandler());
String scheme = "http";
String host = "localhost";
@@ -58,7 +58,7 @@ public class HttpConnectionLifecycleTest extends AbstractHttpClientServerTest
final CountDownLatch headersLatch = new CountDownLatch(1);
final CountDownLatch successLatch = new CountDownLatch(3);
client.newRequest(host, port)
- .listener(new Request.Listener.Adapter()
+ .listener(new Request.Listener.Empty()
{
@Override
public void onSuccess(Request request)
@@ -66,7 +66,7 @@ public class HttpConnectionLifecycleTest extends AbstractHttpClientServerTest
successLatch.countDown();
}
})
- .send(new Response.Listener.Adapter()
+ .send(new Response.Listener.Empty()
{
@Override
public void onHeaders(Response response)
@@ -100,7 +100,7 @@ public class HttpConnectionLifecycleTest extends AbstractHttpClientServerTest
@Test
public void test_FailedRequest_RemovesConnection() throws Exception
{
- start(new EmptyHandler());
+ start(new EmptyServerHandler());
String scheme = "http";
String host = "localhost";
@@ -115,7 +115,7 @@ public class HttpConnectionLifecycleTest extends AbstractHttpClientServerTest
final CountDownLatch headersLatch = new CountDownLatch(1);
final CountDownLatch failureLatch = new CountDownLatch(2);
- client.newRequest(host, port).listener(new Request.Listener.Adapter()
+ client.newRequest(host, port).listener(new Request.Listener.Empty()
{
@Override
public void onBegin(Request request)
@@ -129,7 +129,7 @@ public class HttpConnectionLifecycleTest extends AbstractHttpClientServerTest
{
failureLatch.countDown();
}
- }).send(new Response.Listener.Adapter()
+ }).send(new Response.Listener.Empty()
{
@Override
public void onComplete(Result result)
@@ -151,7 +151,7 @@ public class HttpConnectionLifecycleTest extends AbstractHttpClientServerTest
@Test
public void test_BadRequest_RemovesConnection() throws Exception
{
- start(new EmptyHandler());
+ start(new EmptyServerHandler());
String scheme = "http";
String host = "localhost";
@@ -166,7 +166,7 @@ public class HttpConnectionLifecycleTest extends AbstractHttpClientServerTest
final CountDownLatch successLatch = new CountDownLatch(3);
client.newRequest(host, port)
- .listener(new Request.Listener.Adapter()
+ .listener(new Request.Listener.Empty()
{
@Override
public void onBegin(Request request)
@@ -181,7 +181,7 @@ public class HttpConnectionLifecycleTest extends AbstractHttpClientServerTest
successLatch.countDown();
}
})
- .send(new Response.Listener.Adapter()
+ .send(new Response.Listener.Empty()
{
@Override
public void onSuccess(Response response)
@@ -209,7 +209,7 @@ public class HttpConnectionLifecycleTest extends AbstractHttpClientServerTest
@Test
public void test_ConnectionFailure_RemovesConnection() throws Exception
{
- start(new EmptyHandler());
+ start(new EmptyServerHandler());
String scheme = "http";
String host = "localhost";
@@ -226,7 +226,7 @@ public class HttpConnectionLifecycleTest extends AbstractHttpClientServerTest
final CountDownLatch failureLatch = new CountDownLatch(2);
client.newRequest(host, port)
- .listener(new Request.Listener.Adapter()
+ .listener(new Request.Listener.Empty()
{
@Override
public void onFailure(Request request, Throwable failure)
@@ -234,7 +234,7 @@ public class HttpConnectionLifecycleTest extends AbstractHttpClientServerTest
failureLatch.countDown();
}
})
- .send(new Response.Listener.Adapter()
+ .send(new Response.Listener.Empty()
{
@Override
public void onComplete(Result result)
@@ -276,7 +276,7 @@ public class HttpConnectionLifecycleTest extends AbstractHttpClientServerTest
final CountDownLatch latch = new CountDownLatch(1);
client.newRequest(host, port)
- .send(new Response.Listener.Adapter()
+ .send(new Response.Listener.Empty()
{
@Override
public void onComplete(Result result)
@@ -321,7 +321,7 @@ public class HttpConnectionLifecycleTest extends AbstractHttpClientServerTest
final CountDownLatch latch = new CountDownLatch(1);
client.newRequest(host, port)
.content(new ByteBufferContentProvider(ByteBuffer.allocate(16 * 1024 * 1024)))
- .send(new Response.Listener.Adapter()
+ .send(new Response.Listener.Empty()
{
@Override
public void onComplete(Result result)
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpCookieStoreTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpCookieStoreTest.java
index 1a8e54f9225..b616dd18449 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpCookieStoreTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpCookieStoreTest.java
@@ -37,7 +37,7 @@ public class HttpCookieStoreTest
Destination destination = new HttpDestination(client, "http", "localhost", 80);
Assert.assertTrue(cookies.addCookie(destination, new HttpCookie("a", "1")));
- List result = cookies.getCookies(destination, "/");
+ List result = cookies.findCookies(destination, "/");
Assert.assertNotNull(result);
Assert.assertEquals(1, result.size());
HttpCookie cookie = result.get(0);
@@ -52,7 +52,7 @@ public class HttpCookieStoreTest
Destination destination = new HttpDestination(client, "http", "localhost", 80);
Assert.assertTrue(cookies.addCookie(destination, new HttpCookie("a", "1", "child.localhost", "/")));
- List result = cookies.getCookies(destination, "/");
+ List result = cookies.findCookies(destination, "/");
Assert.assertNotNull(result);
Assert.assertEquals(1, result.size());
HttpCookie cookie = result.get(0);
@@ -75,7 +75,7 @@ public class HttpCookieStoreTest
Destination destination = new HttpDestination(client, "http", "localhost", 80);
Assert.assertTrue(cookies.addCookie(destination, new HttpCookie("a", "1", null, "/path")));
- List result = cookies.getCookies(destination, "/");
+ List result = cookies.findCookies(destination, "/");
Assert.assertNotNull(result);
Assert.assertEquals(0, result.size());
}
@@ -87,7 +87,7 @@ public class HttpCookieStoreTest
Destination destination = new HttpDestination(client, "http", "localhost", 80);
Assert.assertTrue(cookies.addCookie(destination, new HttpCookie("a", "1", null, "/")));
- List result = cookies.getCookies(destination, "/path");
+ List result = cookies.findCookies(destination, "/path");
Assert.assertNotNull(result);
Assert.assertEquals(1, result.size());
HttpCookie cookie = result.get(0);
@@ -108,7 +108,7 @@ public class HttpCookieStoreTest
Destination grandChildDestination = new HttpDestination(client, "http", "grand.child.localhost.org", 80);
Assert.assertTrue(cookies.addCookie(grandChildDestination, new HttpCookie("b", "2", null, "/")));
- List result = cookies.getCookies(grandChildDestination, "/path");
+ List result = cookies.findCookies(grandChildDestination, "/path");
Assert.assertNotNull(result);
Assert.assertEquals(2, result.size());
}
@@ -120,7 +120,7 @@ public class HttpCookieStoreTest
Destination destination = new HttpDestination(client, "http", "localhost.org", 80);
Assert.assertTrue(cookies.addCookie(destination, new HttpCookie("a", "1", null, "/", 0, false, false)));
- List result = cookies.getCookies(destination, "/");
+ List result = cookies.findCookies(destination, "/");
Assert.assertNotNull(result);
Assert.assertEquals(0, result.size());
}
@@ -132,7 +132,7 @@ public class HttpCookieStoreTest
Destination destination = new HttpDestination(client, "http", "localhost.org", 80);
Assert.assertTrue(cookies.addCookie(destination, new HttpCookie("a", "1", null, "/", -1, false, true)));
- List result = cookies.getCookies(destination, "/");
+ List result = cookies.findCookies(destination, "/");
Assert.assertNotNull(result);
Assert.assertEquals(0, result.size());
}
@@ -145,6 +145,6 @@ public class HttpCookieStoreTest
Assert.assertTrue(cookies.addCookie(destination, new HttpCookie("a", "1", null, "/", -1, false, true)));
cookies.clear();
- Assert.assertEquals(0, cookies.getCookies(destination, "/").size());
+ Assert.assertEquals(0, cookies.findCookies(destination, "/").size());
}
}
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpCookieTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpCookieTest.java
index c79054096cf..b1cbf7c6e1f 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpCookieTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpCookieTest.java
@@ -59,7 +59,7 @@ public class HttpCookieTest extends AbstractHttpClientServerTest
Assert.assertEquals(200, response.status());
Destination destination = client.getDestination(scheme, host, port);
- List cookies = client.getCookieStore().getCookies(destination, path);
+ List cookies = client.getCookieStore().findCookies(destination, path);
Assert.assertNotNull(cookies);
Assert.assertEquals(1, cookies.size());
HttpCookie cookie = cookies.get(0);
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpDestinationTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpDestinationTest.java
index 2d57e34949c..9cebbf403bc 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpDestinationTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpDestinationTest.java
@@ -32,7 +32,7 @@ public class HttpDestinationTest extends AbstractHttpClientServerTest
@Before
public void init() throws Exception
{
- start(new EmptyHandler());
+ start(new EmptyServerHandler());
}
@Test
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpReceiverTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpReceiverTest.java
index 07f300de06d..d8a8ef4b817 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpReceiverTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpReceiverTest.java
@@ -26,7 +26,7 @@ import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicReference;
import org.eclipse.jetty.client.api.Response;
-import org.eclipse.jetty.client.util.BufferingResponseListener;
+import org.eclipse.jetty.client.util.BlockingResponseListener;
import org.eclipse.jetty.http.HttpFields;
import org.eclipse.jetty.http.HttpHeader;
import org.eclipse.jetty.http.HttpVersion;
@@ -66,6 +66,7 @@ public class HttpReceiverTest
HttpExchange exchange = new HttpExchange(conversation, connection, null, listener);
conversation.exchanges().offer(exchange);
connection.setExchange(exchange);
+ exchange.requestComplete(true);
return exchange;
}
@@ -78,7 +79,7 @@ public class HttpReceiverTest
"\r\n");
final AtomicReference responseRef = new AtomicReference<>();
final CountDownLatch latch = new CountDownLatch(1);
- HttpExchange exchange = newExchange(new Response.Listener.Adapter()
+ HttpExchange exchange = newExchange(new Response.Listener.Empty()
{
@Override
public void onSuccess(Response response)
@@ -110,11 +111,11 @@ public class HttpReceiverTest
"Content-length: " + content.length() + "\r\n" +
"\r\n" +
content);
- BufferingResponseListener listener = new BufferingResponseListener();
+ BlockingResponseListener listener = new BlockingResponseListener();
HttpExchange exchange = newExchange(listener);
exchange.receive();
- Response response = listener.await(5, TimeUnit.SECONDS);
+ Response response = listener.get(5, TimeUnit.SECONDS);
Assert.assertNotNull(response);
Assert.assertEquals(200, response.status());
Assert.assertEquals("OK", response.reason());
@@ -123,7 +124,7 @@ public class HttpReceiverTest
Assert.assertNotNull(headers);
Assert.assertEquals(1, headers.size());
Assert.assertEquals(String.valueOf(content.length()), headers.get(HttpHeader.CONTENT_LENGTH));
- String received = listener.contentAsString("UTF-8");
+ String received = listener.getContent("UTF-8");
Assert.assertEquals(content, received);
}
@@ -137,7 +138,7 @@ public class HttpReceiverTest
"Content-length: " + (content1.length() + content2.length()) + "\r\n" +
"\r\n" +
content1);
- BufferingResponseListener listener = new BufferingResponseListener();
+ BlockingResponseListener listener = new BlockingResponseListener();
HttpExchange exchange = newExchange(listener);
exchange.receive();
endPoint.setInputEOF();
@@ -145,7 +146,7 @@ public class HttpReceiverTest
try
{
- listener.await(5, TimeUnit.SECONDS);
+ listener.get(5, TimeUnit.SECONDS);
Assert.fail();
}
catch (ExecutionException e)
@@ -161,7 +162,7 @@ public class HttpReceiverTest
"HTTP/1.1 200 OK\r\n" +
"Content-length: 1\r\n" +
"\r\n");
- BufferingResponseListener listener = new BufferingResponseListener();
+ BlockingResponseListener listener = new BlockingResponseListener();
HttpExchange exchange = newExchange(listener);
exchange.receive();
// Simulate an idle timeout
@@ -169,7 +170,7 @@ public class HttpReceiverTest
try
{
- listener.await(5, TimeUnit.SECONDS);
+ listener.get(5, TimeUnit.SECONDS);
Assert.fail();
}
catch (ExecutionException e)
@@ -185,13 +186,13 @@ public class HttpReceiverTest
"HTTP/1.1 200 OK\r\n" +
"Content-length: A\r\n" +
"\r\n");
- BufferingResponseListener listener = new BufferingResponseListener();
+ BlockingResponseListener listener = new BlockingResponseListener();
HttpExchange exchange = newExchange(listener);
exchange.receive();
try
{
- listener.await(5, TimeUnit.SECONDS);
+ listener.get(5, TimeUnit.SECONDS);
Assert.fail();
}
catch (ExecutionException e)
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpRequestAbortTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpRequestAbortTest.java
new file mode 100644
index 00000000000..a6c15f85246
--- /dev/null
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpRequestAbortTest.java
@@ -0,0 +1,188 @@
+//
+// ========================================================================
+// Copyright (c) 1995-2012 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.client;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.eclipse.jetty.client.api.ContentResponse;
+import org.eclipse.jetty.client.api.Request;
+import org.eclipse.jetty.client.util.ByteBufferContentProvider;
+import org.eclipse.jetty.server.handler.AbstractHandler;
+import org.eclipse.jetty.util.IO;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class HttpRequestAbortTest extends AbstractHttpClientServerTest
+{
+ @Test
+ public void testAbortOnQueued() throws Exception
+ {
+ start(new EmptyServerHandler());
+
+ final AtomicBoolean begin = new AtomicBoolean();
+ try
+ {
+ client.newRequest("localhost", connector.getLocalPort())
+ .listener(new Request.Listener.Empty()
+ {
+ @Override
+ public void onQueued(Request request)
+ {
+ request.abort();
+ }
+
+ @Override
+ public void onBegin(Request request)
+ {
+ begin.set(true);
+ }
+ })
+ .send().get(5, TimeUnit.SECONDS);
+ fail();
+ }
+ catch (ExecutionException x)
+ {
+ HttpRequestException xx = (HttpRequestException)x.getCause();
+ Request request = xx.getRequest();
+ Assert.assertNotNull(request);
+ Assert.assertFalse(begin.get());
+ }
+ }
+
+ @Test
+ public void testAbortOnBegin() throws Exception
+ {
+ start(new EmptyServerHandler());
+
+ final AtomicBoolean headers = new AtomicBoolean();
+ try
+ {
+ client.newRequest("localhost", connector.getLocalPort())
+ .listener(new Request.Listener.Empty()
+ {
+ @Override
+ public void onBegin(Request request)
+ {
+ request.abort();
+ }
+
+ @Override
+ public void onHeaders(Request request)
+ {
+ headers.set(true);
+ }
+ })
+ .send().get(5, TimeUnit.SECONDS);
+ fail();
+ }
+ catch (ExecutionException x)
+ {
+ HttpRequestException xx = (HttpRequestException)x.getCause();
+ Request request = xx.getRequest();
+ Assert.assertNotNull(request);
+ Assert.assertFalse(headers.get());
+ }
+ }
+
+ @Test
+ public void testAbortOnHeaders() throws Exception
+ {
+ start(new EmptyServerHandler());
+
+ ContentResponse response = client.newRequest("localhost", connector.getLocalPort())
+ .listener(new Request.Listener.Empty()
+ {
+ @Override
+ public void onHeaders(Request request)
+ {
+ // Too late to abort
+ request.abort();
+ }
+ })
+ .send().get(5, TimeUnit.SECONDS);
+ assertEquals(200, response.status());
+ }
+
+ @Test
+ public void testAbortOnHeadersWithContent() throws Exception
+ {
+ final AtomicReference failure = new AtomicReference<>();
+ start(new AbstractHandler()
+ {
+ @Override
+ public void handle(String target, org.eclipse.jetty.server.Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
+ {
+ try
+ {
+ baseRequest.setHandled(true);
+ IO.copy(request.getInputStream(), response.getOutputStream());
+ }
+ catch (IOException x)
+ {
+ failure.set(x);
+ throw x;
+ }
+ }
+ });
+
+ // Test can behave in 2 ways:
+ // A) if the request is failed before the request arrived, then we get an ExecutionException
+ // B) if the request is failed after the request arrived, then we get a 500
+ try
+ {
+ ContentResponse response = client.newRequest("localhost", connector.getLocalPort())
+ .listener(new Request.Listener.Empty()
+ {
+ @Override
+ public void onHeaders(Request request)
+ {
+ request.abort();
+ }
+ })
+ .content(new ByteBufferContentProvider(ByteBuffer.wrap(new byte[]{0}), ByteBuffer.wrap(new byte[]{1}))
+ {
+ @Override
+ public long length()
+ {
+ return -1;
+ }
+ })
+ .send().get(5, TimeUnit.SECONDS);
+ Assert.assertNotNull(failure.get());
+ assertEquals(500, response.status());
+ }
+ catch (ExecutionException x)
+ {
+ HttpRequestException xx = (HttpRequestException)x.getCause();
+ Request request = xx.getRequest();
+ Assert.assertNotNull(request);
+ }
+ }
+}
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpResponseAbortTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpResponseAbortTest.java
new file mode 100644
index 00000000000..30a5dbb5cca
--- /dev/null
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpResponseAbortTest.java
@@ -0,0 +1,169 @@
+//
+// ========================================================================
+// Copyright (c) 1995-2012 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.client;
+
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.eclipse.jetty.client.api.ContentResponse;
+import org.eclipse.jetty.client.api.Response;
+import org.eclipse.jetty.client.api.Result;
+import org.eclipse.jetty.server.Request;
+import org.eclipse.jetty.server.handler.AbstractHandler;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class HttpResponseAbortTest extends AbstractHttpClientServerTest
+{
+ @Test
+ public void testAbortOnBegin() throws Exception
+ {
+ start(new EmptyServerHandler());
+
+ final CountDownLatch latch = new CountDownLatch(1);
+ client.newRequest("localhost", connector.getLocalPort())
+ .send(new Response.Listener.Empty()
+ {
+ @Override
+ public void onBegin(Response response)
+ {
+ response.abort();
+ }
+
+ @Override
+ public void onComplete(Result result)
+ {
+ Assert.assertTrue(result.isFailed());
+ latch.countDown();
+ }
+ });
+ Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
+ }
+
+ @Test
+ public void testAbortOnHeaders() throws Exception
+ {
+ start(new EmptyServerHandler());
+
+ final CountDownLatch latch = new CountDownLatch(1);
+ client.newRequest("localhost", connector.getLocalPort())
+ .send(new Response.Listener.Empty()
+ {
+ @Override
+ public void onHeaders(Response response)
+ {
+ response.abort();
+ }
+
+ @Override
+ public void onComplete(Result result)
+ {
+ Assert.assertTrue(result.isFailed());
+ latch.countDown();
+ }
+ });
+ Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
+ }
+
+ @Test
+ public void testAbortOnContent() throws Exception
+ {
+ start(new AbstractHandler()
+ {
+ @Override
+ public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
+ {
+ try
+ {
+ baseRequest.setHandled(true);
+ OutputStream output = response.getOutputStream();
+ output.write(1);
+ output.flush();
+ output.write(2);
+ output.flush();
+ }
+ catch (IOException ignored)
+ {
+ // The client may have already closed, and we'll get an exception here, but it's expected
+ }
+ }
+ });
+
+ final CountDownLatch latch = new CountDownLatch(1);
+ client.newRequest("localhost", connector.getLocalPort())
+ .send(new Response.Listener.Empty()
+ {
+ @Override
+ public void onContent(Response response, ByteBuffer content)
+ {
+ response.abort();
+ }
+
+ @Override
+ public void onComplete(Result result)
+ {
+ Assert.assertTrue(result.isFailed());
+ latch.countDown();
+ }
+ });
+ Assert.assertTrue(latch.await(555, TimeUnit.SECONDS));
+ }
+
+ @Test(expected = CancellationException.class)
+ public void testCancelFuture() throws Exception
+ {
+ final CountDownLatch latch = new CountDownLatch(1);
+ final AtomicReference> ref = new AtomicReference<>();
+ start(new AbstractHandler()
+ {
+ @Override
+ public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
+ {
+ try
+ {
+ latch.await(5, TimeUnit.SECONDS);
+ baseRequest.setHandled(true);
+ ref.get().cancel(true);
+ OutputStream output = response.getOutputStream();
+ output.write(new byte[]{0, 1, 2, 3, 4, 5, 6, 7});
+ }
+ catch (InterruptedException x)
+ {
+ throw new InterruptedIOException();
+ }
+ }
+ });
+
+ Future future = client.newRequest("localhost", connector.getLocalPort()).send();
+ ref.set(future);
+ latch.countDown();
+
+ future.get(5, TimeUnit.SECONDS);
+ }
+}
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpSenderTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpSenderTest.java
index 7a25877e952..9a5c0ec891c 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpSenderTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpSenderTest.java
@@ -60,7 +60,7 @@ public class HttpSenderTest
Request request = client.newRequest(URI.create("http://localhost/"));
final CountDownLatch headersLatch = new CountDownLatch(1);
final CountDownLatch successLatch = new CountDownLatch(1);
- request.listener(new Request.Listener.Adapter()
+ request.listener(new Request.Listener.Empty()
{
@Override
public void onHeaders(Request request)
@@ -121,7 +121,7 @@ public class HttpSenderTest
HttpConnection connection = new HttpConnection(client, endPoint, destination);
Request request = client.newRequest(URI.create("http://localhost/"));
final CountDownLatch failureLatch = new CountDownLatch(2);
- request.listener(new Request.Listener.Adapter()
+ request.listener(new Request.Listener.Empty()
{
@Override
public void onFailure(Request request, Throwable x)
@@ -129,7 +129,7 @@ public class HttpSenderTest
failureLatch.countDown();
}
});
- connection.send(request, new Response.Listener.Adapter()
+ connection.send(request, new Response.Listener.Empty()
{
@Override
public void onComplete(Result result)
@@ -150,7 +150,7 @@ public class HttpSenderTest
HttpConnection connection = new HttpConnection(client, endPoint, destination);
Request request = client.newRequest(URI.create("http://localhost/"));
final CountDownLatch failureLatch = new CountDownLatch(2);
- request.listener(new Request.Listener.Adapter()
+ request.listener(new Request.Listener.Empty()
{
@Override
public void onFailure(Request request, Throwable x)
@@ -158,7 +158,7 @@ public class HttpSenderTest
failureLatch.countDown();
}
});
- connection.send(request, new Response.Listener.Adapter()
+ connection.send(request, new Response.Listener.Empty()
{
@Override
public void onComplete(Result result)
@@ -188,7 +188,7 @@ public class HttpSenderTest
request.content(new ByteBufferContentProvider(ByteBuffer.wrap(content.getBytes("UTF-8"))));
final CountDownLatch headersLatch = new CountDownLatch(1);
final CountDownLatch successLatch = new CountDownLatch(1);
- request.listener(new Request.Listener.Adapter()
+ request.listener(new Request.Listener.Empty()
{
@Override
public void onHeaders(Request request)
@@ -223,7 +223,7 @@ public class HttpSenderTest
request.content(new ByteBufferContentProvider(ByteBuffer.wrap(content1.getBytes("UTF-8")), ByteBuffer.wrap(content2.getBytes("UTF-8"))));
final CountDownLatch headersLatch = new CountDownLatch(1);
final CountDownLatch successLatch = new CountDownLatch(1);
- request.listener(new Request.Listener.Adapter()
+ request.listener(new Request.Listener.Empty()
{
@Override
public void onHeaders(Request request)
@@ -265,7 +265,7 @@ public class HttpSenderTest
});
final CountDownLatch headersLatch = new CountDownLatch(1);
final CountDownLatch successLatch = new CountDownLatch(1);
- request.listener(new Request.Listener.Adapter()
+ request.listener(new Request.Listener.Empty()
{
@Override
public void onHeaders(Request request)
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/api/Usage.java b/jetty-client/src/test/java/org/eclipse/jetty/client/api/Usage.java
index d3babdf8ea8..55dbec3e87c 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/api/Usage.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/api/Usage.java
@@ -27,7 +27,7 @@ import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import org.eclipse.jetty.client.HttpClient;
-import org.eclipse.jetty.client.util.BufferingResponseListener;
+import org.eclipse.jetty.client.util.BlockingResponseListener;
import org.eclipse.jetty.client.util.PathContentProvider;
import org.eclipse.jetty.client.util.StreamingResponseListener;
import org.eclipse.jetty.http.HttpCookie;
@@ -68,7 +68,7 @@ public class Usage
.param("a", "b")
.header("X-Header", "Y-value")
.agent("Jetty HTTP Client")
- .decoder(null)
+// .decoder(null)
.content(null)
.idleTimeout(5000L);
Future responseFuture = request.send();
@@ -82,7 +82,7 @@ public class Usage
HttpClient client = new HttpClient();
final AtomicReference responseRef = new AtomicReference<>();
final CountDownLatch latch = new CountDownLatch(1);
- client.newRequest("localhost", 8080).send(new Response.Listener.Adapter()
+ client.newRequest("localhost", 8080).send(new Response.Listener.Empty()
{
@Override
public void onSuccess(Response response)
@@ -102,7 +102,7 @@ public class Usage
{
HttpClient client = new HttpClient();
Response response = client.newRequest("localhost", 8080)
- .listener(new Request.Listener.Adapter()
+ .listener(new Request.Listener.Empty()
{
@Override
public void onSuccess(Request request)
@@ -119,9 +119,9 @@ public class Usage
try (Connection connection = client.getDestination("http", "localhost", 8080).newConnection().get(5, TimeUnit.SECONDS))
{
Request request = client.newRequest("localhost", 8080);
- BufferingResponseListener listener = new BufferingResponseListener();
+ BlockingResponseListener listener = new BlockingResponseListener();
connection.send(request, listener);
- Response response = listener.await(5, TimeUnit.SECONDS);
+ Response response = listener.get(5, TimeUnit.SECONDS);
Assert.assertNotNull(response);
Assert.assertEquals(200, response.status());
}
diff --git a/jetty-client/src/test/resources/realm.properties b/jetty-client/src/test/resources/realm.properties
new file mode 100644
index 00000000000..54ace472cb6
--- /dev/null
+++ b/jetty-client/src/test/resources/realm.properties
@@ -0,0 +1,3 @@
+# Format is :,
+basic:basic
+digest:digest
diff --git a/jetty-distribution/pom.xml b/jetty-distribution/pom.xml
index b77c9dd653d..a348cfe27d0 100644
--- a/jetty-distribution/pom.xml
+++ b/jetty-distribution/pom.xml
@@ -349,6 +349,12 @@
${project.version}