true but {@link #setProxyServer(ProxyServer)} was used
* to explicitly set a proxy server, the latter is preferred.
*
* See http://download.oracle.com/javase/1.4.2/docs/guide/net/properties.html
*/
public Builder setUseProxyProperties(boolean useProxyProperties) {
this.useProxyProperties = useProxyProperties;
return this;
}
public Builder setIOThreadMultiplier(int multiplier){
this.ioThreadMultiplier = multiplier;
return this;
}
/**
* Set the {@link HostnameVerifier}
* @param hostnameVerifier {@link HostnameVerifier}
* @return this
*/
public Builder setHostnameVerifier(HostnameVerifier hostnameVerifier){
this.hostnameVerifier = hostnameVerifier;
return this;
}
/**
* Create a config builder with values taken from the given prototype configuration.
*
* @param prototype the configuration to use as a prototype.
*/
public Builder(AsyncHttpClientConfig prototype) {
allowPoolingConnection = prototype.getAllowPoolingConnection();
providerConfig = prototype.getAsyncHttpProviderConfig();
connectionsPool = prototype.getConnectionsPool();
defaultConnectionTimeOutInMs = prototype.getConnectionTimeoutInMs();
defaultIdleConnectionInPoolTimeoutInMs = prototype.getIdleConnectionInPoolTimeoutInMs();
allowPoolingConnection = prototype.getKeepAlive();
defaultMaxConnectionPerHost = prototype.getMaxConnectionPerHost();
maxDefaultRedirects = prototype.getMaxRedirects();
defaultMaxTotalConnections = prototype.getMaxTotalConnections();
proxyServer = prototype.getProxyServer();
realm = prototype.getRealm();
defaultRequestTimeoutInMs = prototype.getRequestTimeoutInMs();
sslContext = prototype.getSSLContext();
sslEngineFactory = prototype.getSSLEngineFactory();
userAgent = prototype.getUserAgent();
requestFilters.clear();
responseFilters.clear();
requestFilters.addAll(prototype.getRequestFilters());
responseFilters.addAll(prototype.getResponseFilters());
useRawUrl = prototype.isUseRawUrl();
ioThreadMultiplier = prototype.getIoThreadMultiplier();
}
/**
* Build an {@link AsyncHttpClientConfig}
*
* @return an {@link AsyncHttpClientConfig}
*/
public AsyncHttpClientConfig build() {
if ( applicationThreadPool.isShutdown() ) {
throw new IllegalStateException( "ExecutorServices closed" );
}
if (proxyServer == null && useProxyProperties) {
proxyServer = ProxyUtils.createProxy(System.getProperties());
}
return new AsyncHttpClientConfig(defaultMaxTotalConnections,
defaultMaxConnectionPerHost,
defaultConnectionTimeOutInMs,
defaultIdleConnectionInPoolTimeoutInMs,
defaultRequestTimeoutInMs,
redirectEnabled,
maxDefaultRedirects,
compressionEnabled,
userAgent,
allowPoolingConnection,
reaper,
applicationThreadPool,
proxyServer,
sslContext,
sslEngineFactory,
providerConfig,
connectionsPool,
realm,
requestFilters,
responseFilters,
ioExceptionFilters,
requestCompressionLevel,
maxRequestRetry,
allowSslConnectionPool,
useRawUrl,
removeQueryParamOnRedirect,
hostnameVerifier,
ioThreadMultiplier);
}
}
}
async-http-client-1.6.5/src/main/java/com/ning/http/client/AsyncHttpClientConfigBean.java 0000664 0000000 0000000 00000021152 11665530560 0031336 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
package com.ning.http.client;
import com.ning.http.client.filter.IOExceptionFilter;
import com.ning.http.client.filter.RequestFilter;
import com.ning.http.client.filter.ResponseFilter;
import com.ning.http.util.ProxyUtils;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import java.util.LinkedList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
/**
* Simple JavaBean version of {@link AsyncHttpClientConfig}
*/
public class AsyncHttpClientConfigBean extends AsyncHttpClientConfig {
public AsyncHttpClientConfigBean() {
configureExecutors();
configureDefaults();
configureFilters();
}
void configureFilters() {
requestFilters = new LinkedList
* This class introduces new call: getResponse(), that blocks caller thread as
* long as headers are received, and return Response as soon as possible, but
* still pouring response body into supplied output stream. This handler is
* meant for situations when the "recommended" way (using
* client.prepareGet("http://foo.com/aResource").execute().get()
* would not work for you, since a potentially large response body is about to
* be GETted, but you need headers first, or you don't know yet (depending on
* some logic, maybe coming from headers) where to save the body, or you just
* want to leave body stream to some other component to consume it.
*
* All these above means that this AsyncHandler needs a bit of different * handling than "recommended" way. Some examples: * *
* FileOutputStream fos = ...
* BodyDeferringAsyncHandler bdah = new BodyDeferringAsyncHandler(fos);
* // client executes async
* Future<Response> fr = client.prepareGet("http://foo.com/aresource").execute(
* bdah);
* // main thread will block here until headers are available
* Response response = bdah.getResponse();
* // you can continue examine headers while actual body download happens
* // in separate thread
* // ...
* // finally "join" the download
* fr.get();
*
*
*
* PipedOutputStream pout = new PipedOutputStream();
* BodyDeferringAsyncHandler bdah = new BodyDeferringAsyncHandler(pout);
* // client executes async
* Future<Response> fr = client.prepareGet("http://foo.com/aresource").execute(bdah);
* // main thread will block here until headers are available
* Response response = bdah.getResponse();
* if (response.getStatusCode() == 200) {
* InputStream pin = new BodyDeferringInputStream(fr,new PipedInputStream(pout));
* // consume InputStream
* ...
* } else {
* // handle unexpected response status code
* ...
* }
*
*
*/
public class BodyDeferringAsyncHandler implements AsyncHandlernull
* in case of some errors.
*
* @return a {@link Response}
* @throws InterruptedException
*/
public Response getResponse() throws InterruptedException, IOException {
// block here as long as headers arrive
headersArrived.await();
try {
semaphore.acquire();
if (throwable != null) {
IOException ioe = new IOException(throwable.getMessage());
ioe.initCause(throwable);
throw ioe;
} else {
return response;
}
} finally {
semaphore.release();
}
}
// ==
/**
* A simple helper class that is used to perform automatic "join" for async
* download and the error checking of the Future of the request.
*/
public static class BodyDeferringInputStream extends FilterInputStream {
private final Futurenull. See
* {@link BodyDeferringAsyncHandler#getResponse()} method for details.
*
* @return a {@link Response}
* @throws InterruptedException
*/
public Response getAsapResponse() throws InterruptedException,
IOException {
return bdah.getResponse();
}
/**
* Delegates to Future#get() method. Will block
* as long as complete response arrives.
*
* @return a {@link Response}
* @throws InterruptedException
* @throws ExecutionException
*/
public Response getLastResponse() throws InterruptedException,
ExecutionException {
return future.get();
}
}
} async-http-client-1.6.5/src/main/java/com/ning/http/client/BodyGenerator.java 0000664 0000000 0000000 00000002470 11665530560 0027114 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
package com.ning.http.client;
import java.io.IOException;
/**
* Creates a request body.
*/
public interface BodyGenerator {
/**
* Creates a new instance of the request body to be read. While each invocation of this method is supposed to create
* a fresh instance of the body, the actual contents of all these body instances is the same. For example, the body
* needs to be resend after an authentication challenge of a redirect.
*
* @return The request body, never {@code null}.
* @throws IOException If the body could not be created.
*/
Body createBody()
throws IOException;
}
async-http-client-1.6.5/src/main/java/com/ning/http/client/ByteArrayPart.java 0000664 0000000 0000000 00000002601 11665530560 0027075 0 ustar 00root root 0000000 0000000 /*
* 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.
*
*/
package com.ning.http.client;
public class ByteArrayPart implements Part {
private String name;
private String fileName;
private byte[] data;
private String mimeType;
private String charSet;
public ByteArrayPart(String name, String fileName, byte[] data, String mimeType, String charSet) {
this.name = name;
this.fileName = fileName;
this.data = data;
this.mimeType = mimeType;
this.charSet = charSet;
}
public String getName() {
return name;
}
public String getFileName() {
return fileName;
}
public byte[] getData() {
return data;
}
public String getMimeType() {
return mimeType;
}
public String getCharSet() {
return charSet;
}
}
async-http-client-1.6.5/src/main/java/com/ning/http/client/ConnectionsPool.java 0000664 0000000 0000000 00000003642 11665530560 0027466 0 ustar 00root root 0000000 0000000 /*
* 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.
*
*/
package com.ning.http.client;
/**
* An interface used by an {@link AsyncHttpProvider} for caching http connections.
*/
public interface ConnectionsPoolAdds 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}. *
*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 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 A list of ({@code Runnable}, {@code Executor}) pairs that guarantees
* that every {@code Runnable} that is added using the add method will be
* executed in its associated {@code Executor} after {@link #run()} is called.
* {@code Runnable}s added after {@code run} is called are still guaranteed to
* execute.
*
* @author Nishant Thakkar
* @author Sven Mawson
* @since 1
*/
public final class ExecutionList implements Runnable {
// Logger to log exceptions caught when running runnables.
private static final Logger log =
Logger.getLogger(ExecutionList.class.getName());
// The runnable,executor pairs to execute.
private final Queue