private HttpClient getClient() {
HttpClient httpClient = new HttpClient();
httpClient.getParams().setParameter("http.protocol.content-charset", "gbk");
httpClient.getParams().setSoTimeout(timeout);
if (useSSL) {
if (sslPort > 0) {
Protocol myhttps =
new Protocol(
"https", (ProtocolSocketFactory) new EasySSLProtocolSocketFactory(), sslPort);
Protocol.registerProtocol("https", myhttps);
}
}
if (useProxy) {
HostConfiguration hc = new HostConfiguration();
hc.setProxy(proxyUrl, proxyPort);
httpClient.setHostConfiguration(hc);
if (proxyUser != null) {
httpClient
.getState()
.setProxyCredentials(
AuthScope.ANY, new UsernamePasswordCredentials(proxyUser, proxyPassword));
}
}
return httpClient;
}
private void configureHttpClient() {
MultiThreadedHttpConnectionManager connMgr = new MultiThreadedHttpConnectionManager();
HttpConnectionManagerParams connParams = connMgr.getParams();
connParams.setMaxTotalConnections(maxConnections);
connParams.setMaxConnectionsPerHost(HostConfiguration.ANY_HOST_CONFIGURATION, maxConnections);
connMgr.setParams(connParams);
hc = new HttpClient(connMgr);
// NOTE: These didn't seem to help in my initial testing
// hc.getParams().setParameter("http.tcp.nodelay", true);
// hc.getParams().setParameter("http.connection.stalecheck", false);
if (proxyHost != null) {
HostConfiguration hostConfig = new HostConfiguration();
hostConfig.setProxy(proxyHost, proxyPort);
hc.setHostConfiguration(hostConfig);
log.info("Proxy Host set to " + proxyHost + ":" + proxyPort);
if (proxyUser != null && !proxyUser.trim().equals("")) {
if (proxyDomain != null) {
hc.getState()
.setProxyCredentials(
new AuthScope(proxyHost, proxyPort),
new NTCredentials(proxyUser, proxyPassword, proxyHost, proxyDomain));
} else {
hc.getState()
.setProxyCredentials(
new AuthScope(proxyHost, proxyPort),
new UsernamePasswordCredentials(proxyUser, proxyPassword));
}
}
}
}
/**
* @param sHostname, the host name
* @param sProxyURL The proxy port, null if you don't use a proxy
* @param iProxyPort, proxy port if you use one of -1 if not
* @return An host configuration
*/
private static HostConfiguration getHostConfiguration(
String sHostname, String sProxyURL, int iProxyPort) {
HostConfiguration host = new HostConfiguration();
host.setHost(sHostname);
if (sProxyURL != null && iProxyPort > 0) {
host.setProxy(
ConfigurationManager.getProperty(CONF_NETWORK_PROXY_HOSTNAME),
ConfigurationManager.getInt(CONF_NETWORK_PROXY_PORT));
}
return host;
}
private HttpClient createHttpClient() {
HttpClient client = new HttpClient();
client.getHttpConnectionManager().getParams().setConnectionTimeout(timeout);
client.getParams().setConnectionManagerTimeout(timeout);
if (proxy) {
HostConfiguration hcf = new HostConfiguration();
hcf.setProxy(this.proxyUrl, this.proxyPort);
client.setHostConfiguration(hcf);
}
return client;
}
public HostConfiguration getHostConfiguration(String location) throws IOException {
if (_log.isDebugEnabled()) {
_log.debug("Location is " + location);
}
HostConfiguration hostConfiguration = new HostConfiguration();
hostConfiguration.setHost(new URI(location, false));
if (isProxyHost(hostConfiguration.getHost())) {
hostConfiguration.setProxy(_PROXY_HOST, _PROXY_PORT);
}
HttpConnectionManager httpConnectionManager = _httpClient.getHttpConnectionManager();
HttpConnectionManagerParams httpConnectionManagerParams = httpConnectionManager.getParams();
int defaultMaxConnectionsPerHost =
httpConnectionManagerParams.getMaxConnectionsPerHost(hostConfiguration);
int maxConnectionsPerHost =
GetterUtil.getInteger(
PropsUtil.get(
HttpImpl.class.getName() + ".max.connections.per.host",
new Filter(hostConfiguration.getHost())));
if ((maxConnectionsPerHost > 0) && (maxConnectionsPerHost != defaultMaxConnectionsPerHost)) {
httpConnectionManagerParams.setMaxConnectionsPerHost(
hostConfiguration, maxConnectionsPerHost);
}
int timeout =
GetterUtil.getInteger(
PropsUtil.get(
HttpImpl.class.getName() + ".timeout", new Filter(hostConfiguration.getHost())));
if (timeout > 0) {
HostParams hostParams = hostConfiguration.getParams();
hostParams.setIntParameter(HttpConnectionParams.CONNECTION_TIMEOUT, timeout);
hostParams.setIntParameter(HttpConnectionParams.SO_TIMEOUT, timeout);
}
return hostConfiguration;
}
/**
* Creates a new connection to the server.
*
* @param builder The HttpFileSystemConfigBuilder.
* @param scheme The protocol.
* @param hostname The hostname.
* @param port The port number.
* @param username The username.
* @param password The password
* @param fileSystemOptions The file system options.
* @return a new HttpClient connection.
* @throws FileSystemException if an error occurs.
* @since 2.0
*/
public static HttpClient createConnection(
HttpFileSystemConfigBuilder builder,
String scheme,
String hostname,
int port,
String username,
String password,
FileSystemOptions fileSystemOptions)
throws FileSystemException {
HttpClient client;
try {
HttpConnectionManager mgr = new MultiThreadedHttpConnectionManager();
HttpConnectionManagerParams connectionMgrParams = mgr.getParams();
client = new HttpClient(mgr);
final HostConfiguration config = new HostConfiguration();
config.setHost(hostname, port, scheme);
if (fileSystemOptions != null) {
String proxyHost = builder.getProxyHost(fileSystemOptions);
int proxyPort = builder.getProxyPort(fileSystemOptions);
if (proxyHost != null && proxyHost.length() > 0 && proxyPort > 0) {
config.setProxy(proxyHost, proxyPort);
}
UserAuthenticator proxyAuth = builder.getProxyAuthenticator(fileSystemOptions);
if (proxyAuth != null) {
UserAuthenticationData authData =
UserAuthenticatorUtils.authenticate(
proxyAuth,
new UserAuthenticationData.Type[] {
UserAuthenticationData.USERNAME, UserAuthenticationData.PASSWORD
});
if (authData != null) {
final UsernamePasswordCredentials proxyCreds =
new UsernamePasswordCredentials(
UserAuthenticatorUtils.toString(
UserAuthenticatorUtils.getData(
authData, UserAuthenticationData.USERNAME, null)),
UserAuthenticatorUtils.toString(
UserAuthenticatorUtils.getData(
authData, UserAuthenticationData.PASSWORD, null)));
AuthScope scope = new AuthScope(proxyHost, AuthScope.ANY_PORT);
client.getState().setProxyCredentials(scope, proxyCreds);
}
if (builder.isPreemptiveAuth(fileSystemOptions)) {
HttpClientParams httpClientParams = new HttpClientParams();
httpClientParams.setAuthenticationPreemptive(true);
client.setParams(httpClientParams);
}
}
Cookie[] cookies = builder.getCookies(fileSystemOptions);
if (cookies != null) {
client.getState().addCookies(cookies);
}
}
/**
* ConnectionManager set methodsmust be called after the host & port and proxy host & port are
* set in the HostConfiguration. They are all used as part of the key when
* HttpConnectionManagerParams tries to locate the host configuration.
*/
connectionMgrParams.setMaxConnectionsPerHost(
config, builder.getMaxConnectionsPerHost(fileSystemOptions));
connectionMgrParams.setMaxTotalConnections(builder.getMaxTotalConnections(fileSystemOptions));
client.setHostConfiguration(config);
if (username != null) {
final UsernamePasswordCredentials creds =
new UsernamePasswordCredentials(username, password);
AuthScope scope = new AuthScope(hostname, AuthScope.ANY_PORT);
client.getState().setCredentials(scope, creds);
}
client.executeMethod(new HeadMethod());
} catch (final Exception exc) {
throw new FileSystemException(
"vfs.provider.http/connect.error", new Object[] {hostname}, exc);
}
return client;
}
protected void applyProxy(HttpMethodBase method, String host) {
HostConfiguration hc = new HostConfiguration();
hc.setHost(host);
hc.setProxy(proxyHost, proxyPort);
method.setHostConfiguration(hc);
}
public static void addProxy(final HostConfiguration config) {
final String host = System.getProperty(HTTP_PROXYHOST);
final String port = System.getProperty(HTTP_PROXYPORT, "-1");
if (host != null && host.trim().length() > 0) config.setProxy(host, Integer.valueOf(port));
}