Merge branch 'master' of github.com:AsyncHttpClient/async-http-client

Author: jfarcand

src/main/java/com/ning/http/client/AsyncHttpClient.java

@@ -223,11 +223,11 @@ private BoundRequestBuilder(Request prototype) {
             super(BoundRequestBuilder.class, prototype);
         }
 
-        public <T> Future<T> execute(AsyncHandler<T> handler) throws IOException {
+        public <T> ListenableFuture<T> execute(AsyncHandler<T> handler) throws IOException {
             return AsyncHttpClient.this.executeRequest(build(), handler);
         }
 
-        public Future<Response> execute() throws IOException {
+        public ListenableFuture<Response> execute() throws IOException {
             return AsyncHttpClient.this.executeRequest(build(), new AsyncCompletionHandlerBase());
         }
 
@@ -468,7 +468,7 @@ public BoundRequestBuilder prepareRequest(Request request) {
      * @return a {@link Future} of type T
      * @throws IOException
      */
-    public <T> Future<T> executeRequest(Request request, AsyncHandler<T> handler) throws IOException {
+    public <T> ListenableFuture<T> executeRequest(Request request, AsyncHandler<T> handler) throws IOException {
 
         FilterContext fc = new FilterContext.FilterContextBuilder().asyncHandler(handler).request(request).build();
         fc  = preProcessRequest(fc);
@@ -482,7 +482,7 @@ public <T> Future<T> executeRequest(Request request, AsyncHandler<T> handler) th
      * @return a {@link Future} of type Response
      * @throws IOException
      */
-    public Future<Response> executeRequest(Request request) throws IOException {
+    public ListenableFuture<Response> executeRequest(Request request) throws IOException {
         FilterContext fc = new FilterContext.FilterContextBuilder().asyncHandler(new AsyncCompletionHandlerBase()).request(request).build();
         fc  = preProcessRequest(fc);
         return httpProvider.execute(fc.getRequest(), fc.getAsyncHandler());

src/main/java/com/ning/http/client/AsyncHttpProvider.java

@@ -29,10 +29,10 @@ public interface AsyncHttpProvider<A> {
      * Execute the request and invoke the {@link AsyncHandler} when the response arrive.
      *
      * @param handler an instance of {@link AsyncHandler}
-     * @return a {@link java.util.concurrent.Future} of Type T.
+     * @return a {@link ListenableFuture} of Type T.
      * @throws IOException
      */
-    public <T> Future<T> execute(Request request, AsyncHandler<T> handler) throws IOException;
+    public <T> ListenableFuture<T> execute(Request request, AsyncHandler<T> handler) throws IOException;
 
     /**
      * Close the current underlying TCP/HTTP connection.

src/main/java/com/ning/http/client/FutureImpl.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2010 Ning, Inc.
+ *
+ * Ning licenses this file to you under the Apache License, version 2.0
+ * (the "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at:
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.ning.http.client;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Future;
+
+/**
+ * Extended {@link Future}
+ *
+ * @param <V> Type of the value that will be returned.
+ */
+public interface ListenableFuture<V> extends Future<V> {
+
+    /**
+     * Execute a {@link Callable}  and if there is no exception, mark this Future as done and release the internal lock.
+     *
+     * @param callable
+     */
+    void done(Callable callable);
+
+    /**
+     * Abort the current processing, and propagate the {@link Throwable} to the {@link AsyncHandler} or {@link Future}
+     *
+     * @param t
+     */
+    void abort(Throwable t);
+
+    /**
+     * Set the content that will be returned by this instance
+     *
+     * @param v the content that will be returned by this instance
+     */
+    void content(V v);
+
+    /**
+     * Touch the current instance to prevent external service to times out.
+     */
+    void touch();
+
+    /**
+     * Write the {@link Request} headers
+     */
+    boolean getAndSetWriteHeaders(boolean writeHeader);
+
+    /**
+     * Write the {@link Request} body
+     */
+    boolean getAndSetWriteBody(boolean writeBody);
+
+    /**
+     * <p>Adds a listener and executor to the ListenableFuture.
+     * The listener will be {@linkplain java.util.concurrent.Executor#execute(Runnable) passed
+     * to the executor} for execution when the {@code Future}'s computation is
+     * {@linkplain Future#isDone() complete}.
+     * <p/>
+     * <p>There is no guaranteed ordering of execution of listeners, they may get
+     * called in the order they were added and they may get called out of order,
+     * but any listener added through this method is guaranteed to be called once
+     * the computation is complete.
+     *
+     * @param listener the listener to run when the computation is complete.
+     * @param exec     the executor to run the listener in.
+     * @return this Future
+     * @throws NullPointerException if the executor or listener was null.
+     * @throws java.util.concurrent.RejectedExecutionException
+     *                              if we tried to execute the listener
+     *                              immediately but the executor rejected it.
+     */
+    ListenableFuture<V> addListener(Runnable listener, Executor exec);
+}

src/main/java/com/ning/http/client/ListenableFuture.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2010-2011 Sonatype, Inc. All rights reserved.
+ *
+ * This program is licensed to you under the Apache License Version 2.0,
+ * and you may not use this file except in compliance with the Apache License Version 2.0.
+ * You may obtain a copy of the Apache License Version 2.0 at http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the Apache License Version 2.0 is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
+ */
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.ning.http.client.listenable;
+
+import com.ning.http.client.ListenableFuture;
+
+import java.util.concurrent.Executor;
+
+/**
+ * <p>An abstract base implementation of the listener support provided by
+ * {@link ListenableFuture}. This class uses an {@link ExecutionList} to
+ * guarantee that all registered listeners will be executed. Listener/Executor
+ * pairs are stored in the execution list and executed in the order in which
+ * they were added, but because of thread scheduling issues there is no
+ * guarantee that the JVM will execute them in order. In addition, listeners
+ * added after the task is complete will be executed immediately, even if some
+ * previously added listeners have not yet been executed.
+ *
+ * @author Sven Mawson
+ * @since 1
+ */
+public abstract class AbstractListenableFuture<V> implements ListenableFuture<V> {
+
+    // The execution list to hold our executors.
+    private final ExecutionList executionList = new ExecutionList();
+
+    /*
+    * Adds a listener/executor pair to execution list to execute when this task
+    * is completed.
+    */
+
+    public ListenableFuture<V> addListener(Runnable listener, Executor exec) {
+        executionList.add(listener, exec);
+        return this;
+    }
+
+    /*
+    * Override the done method to execute the execution list.
+    */
+
+    protected void done() {
+        executionList.run();
+    }
+}