/**
* Retrieve the bytes at the specified path.
*
* @param path - encoded but not fully qualified. Must NOT be slash prefixed as it will be
* appended to the host's url
* @return
* @throws com.ettrema.httpclient.HttpException
*/
public synchronized byte[] get(String path)
throws com.ettrema.httpclient.HttpException, NotAuthorizedException, BadRequestException,
ConflictException, NotFoundException {
String url = this.encodedUrl() + path;
final ByteArrayOutputStream out = new ByteArrayOutputStream();
try {
transferService.get(
url,
new StreamReceiver() {
@Override
public void receive(InputStream in) {
try {
IOUtils.copy(in, out);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
},
null,
null);
} catch (CancelledException ex) {
throw new RuntimeException("Should never happen because no progress listener is set", ex);
}
return out.toByteArray();
}
public synchronized void doGet(Path path, final java.io.File file, ProgressListener listener)
throws IOException, NotFoundException, com.ettrema.httpclient.HttpException,
CancelledException, NotAuthorizedException, BadRequestException, ConflictException {
LogUtils.trace(log, "doGet", path);
if (fileSyncer != null) {
fileSyncer.download(this, path, file, listener);
} else {
String url = this.buildEncodedUrl(path);
transferService.get(
url,
new StreamReceiver() {
@Override
public void receive(InputStream in) throws IOException {
OutputStream out = null;
BufferedOutputStream bout = null;
try {
out = FileUtils.openOutputStream(file);
bout = new BufferedOutputStream(out);
IOUtils.copy(in, bout);
bout.flush();
} finally {
IOUtils.closeQuietly(bout);
IOUtils.closeQuietly(out);
}
}
},
null,
listener);
}
}
/**
* Uploads the data. Does not do any file syncronisation
*
* @param newUri - encoded full URL
* @param content
* @param contentLength
* @param contentType
* @return - the result code
*/
public synchronized int doPut(
String newUri,
InputStream content,
Long contentLength,
String contentType,
ProgressListener listener) {
LogUtils.trace(log, "doPut", newUri);
return transferService.put(newUri, content, contentLength, contentType, listener);
}
/** @param timeout the timeout to set */
public void setTimeout(int timeout) {
this.timeout = timeout;
transferService.setTimeout(timeout);
}
/**
* @param url - fully qualified and encoded URL
* @param receiver
* @param rangeList - if null does a normal GET request
* @throws com.ettrema.httpclient.HttpException
* @throws com.ettrema.httpclient.Utils.CancelledException
*/
public synchronized void doGet(
String url, StreamReceiver receiver, List<Range> rangeList, ProgressListener listener)
throws com.ettrema.httpclient.HttpException, Utils.CancelledException, NotAuthorizedException,
BadRequestException, ConflictException, NotFoundException {
transferService.get(url, receiver, rangeList, listener);
}
public Host(
String server,
String rootPath,
Integer port,
String user,
String password,
ProxyDetails proxyDetails,
int timeoutMillis,
Cache<Folder, List<Resource>> cache,
FileSyncer fileSyncer) {
super(
(cache != null
? cache
: new MemoryCache<Folder, List<Resource>>("resource-cache-default", 50, 20)));
if (server == null) {
throw new IllegalArgumentException("host name cannot be null");
}
this.rootPath = rootPath;
this.timeout = timeoutMillis;
this.server = server;
this.port = port;
this.user = user;
this.password = password;
client = new DefaultHttpClient();
HttpParams params = client.getParams();
HttpConnectionParams.setConnectionTimeout(params, 10000);
HttpConnectionParams.setSoTimeout(params, 10000);
if (user != null) {
client
.getCredentialsProvider()
.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(user, password));
PreemptiveAuthInterceptor interceptor = new PreemptiveAuthInterceptor();
client.addRequestInterceptor(interceptor);
}
HttpRequestRetryHandler handler = new DefaultHttpRequestRetryHandler(0, false);
client.setHttpRequestRetryHandler(handler);
if (proxyDetails != null) {
if (proxyDetails.isUseSystemProxy()) {
System.setProperty("java.net.useSystemProxies", "true");
} else {
System.setProperty("java.net.useSystemProxies", "false");
if (proxyDetails.getProxyHost() != null && proxyDetails.getProxyHost().length() > 0) {
HttpHost proxy =
new HttpHost(proxyDetails.getProxyHost(), proxyDetails.getProxyPort(), "http");
client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);
if (proxyDetails.hasAuth()) {
client
.getCredentialsProvider()
.setCredentials(
new AuthScope(proxyDetails.getProxyHost(), proxyDetails.getProxyPort()),
new UsernamePasswordCredentials(
proxyDetails.getUserName(), proxyDetails.getPassword()));
}
}
}
}
transferService = new TransferService(client, connectionListeners);
transferService.setTimeout(timeoutMillis);
this.fileSyncer = fileSyncer;
}