File upload cancelation

[Bjorn Stove]

Hi friends.

Im uploading a file, using on client side HttpClient from org.apache.commons package.

Im streaming the file to the server.

How can I let a user cancel the upload nicely?

Im using HttpClient code like this, implemented with a listener.

                      PostMethod postMethod = new PostMethod(targetURL);

					postMethod.getParams().setBooleanParameter(
							HttpMethodParams.USE_EXPECT_CONTINUE,
							cbxExpectHeader.isSelected());
					try {
						appendMessage("Uploading " + targetFile.getName()
								+ " to " + targetURL);
						Part[] parts = { new FilePart(targetFile.getName(),
								targetFile) };
                          HttpClient client = new HttpClient();
					client.getHttpConnectionManager().getParams()
								.setConnectionTimeout(5000);

						// New code
						MultipartRequestEntity mpre = new MultipartRequestEntity(
								parts, postMethod.getParams());
						// filePost.setRequestEntity(
						// new MultipartRequestEntity(parts,
						// filePost.getParams())
						// );
						CountingMultiPartRequestEntity.ProgressListener listener = new ProgressListenerImpl();

						CountingMultiPartRequestEntity cmr = new CountingMultiPartRequestEntity(
								mpre, listener, client);
						
//						postMethod.setRequestEntity(cmr);
						
                           CountingMultiPartRequestEntity.isCanceled = false;
                           
						int status = client.executeMethod(postMethod);
						
						if (status == HttpStatus.SC_OK) {
							appendMessage("Upload complete, response="
									+ postMethod.getResponseBodyAsString());
						} else {
							appendMessage("Upload failed, response="
									+ HttpStatus.getStatusText(status));
						}
					} catch (Exception ex) {
						appendMessage("ERROR: " + ex.getClass().getName() + " "
								+ ex.getMessage());
						ex.printStackTrace();
					} finally {
						postMethod.releaseConnection();
					}

				}
			});   

My class with listener and write methods...

  import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;

import org.apache.commons.httpclient.HostConfiguration;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpConnection;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.RequestEntity;

public class CountingMultiPartRequestEntity implements RequestEntity {

public static boolean isCanceled = false;

private final RequestEntity delegate;

private final ProgressListener listener;

private HttpClient client;

private PostMethod postMethod;

public CountingMultiPartRequestEntity(final RequestEntity entity, ProgressListener listener, HttpClient client) {
super();
this.delegate = entity;
this.listener = listener;
this.client = client;

}

public long getContentLength() {
return this.delegate.getContentLength();
}

public String getContentType() {
return this.delegate.getContentType();
}

public boolean isRepeatable() {
return this.delegate.isRepeatable();
}

public void writeRequest(final OutputStream out) throws IOException {
this.delegate.writeRequest(new CountingOutputStream(out, this.listener,this.client));

}

public static interface ProgressListener {
void transferred(long num);
}

public static class CountingOutputStream extends FilterOutputStream {

private final ProgressListener listener;

private long transferred;

private HttpClient client;
private PostMethod postMethod;

public CountingOutputStream(final OutputStream out,
final ProgressListener listener, HttpClient client) {
super(out);
this.listener = listener;
this.transferred = 0;
this.client = client;

}

public void write(byte[] b, int off, int len) throws IOException {
	System.out.println("Writing bytes with array : offset ="+off +"length ="+len);
if (!CountingMultiPartRequestEntity.isCanceled) {
	super.write(b, off, len);
	this.transferred += len;
	this.listener.transferred(this.transferred);
}
else {
	closeConnection();
}
}


public void write(int b) throws IOException {
	System.out.println("Writing single byte= "+ b);
if (!CountingMultiPartRequestEntity.isCanceled) {
	super.write(b);
	this.transferred++;
	this.listener.transferred(this.transferred);
}
else {
	  closeConnection();
}
}

private void closeConnection() {
	//not implemented...
}
}
}
  

How is the best way to cancel the stream to the server.
I havent find anything in HttpClient to achieve this.
Maybe there is a way to subclass and override, but I have not managed to
figure that out.


Any help appreciated

Best Regards
Bjorn

[Angel J Gama]

To cancel an upload, just change the src of the iframe you're doing the uploading work... For example:

<html>
<head>
<script type="text/javascript">
function cancelUpload() {
document.getElementById("uploadArea").src="about:blank";
}
</script>
</head>

<body>
//Here goes your submit form

Press this button if you wish to cancel the upload:
<input type="button" value="Cancel" onclick="cancelUpload();" />

<iframe id="uploadArea" style="display:hidden;" ...>
</iframe>
<body>

Hope this helps