URLRetrieveTestCancelConnectJob.java

/*******************************************************************************
 * Copyright (c) 2009 IBM, and others. 
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.ecf.tests.filetransfer;

import java.io.File;
import java.io.IOException;
import java.net.URL;

import org.apache.commons.httpclient.server.HttpRequestHandler;
import org.apache.commons.httpclient.server.ResponseWriter;
import org.apache.commons.httpclient.server.SimpleHttpServer;
import org.apache.commons.httpclient.server.SimpleHttpServerConnection;
import org.apache.commons.httpclient.server.SimpleRequest;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.ecf.filetransfer.FileTransferJob;
import org.eclipse.ecf.filetransfer.IFileTransferListener;
import org.eclipse.ecf.filetransfer.UserCancelledException;
import org.eclipse.ecf.filetransfer.events.IFileTransferConnectStartEvent;
import org.eclipse.ecf.filetransfer.events.IIncomingFileTransferReceiveDataEvent;
import org.eclipse.ecf.filetransfer.events.IIncomingFileTransferReceiveDoneEvent;
import org.eclipse.ecf.filetransfer.events.IIncomingFileTransferReceiveStartEvent;
import org.eclipse.ecf.filetransfer.events.socket.ISocketConnectedEvent;
import org.eclipse.ecf.filetransfer.events.socket.ISocketEvent;
import org.eclipse.ecf.filetransfer.events.socket.ISocketEventSource;
import org.eclipse.ecf.filetransfer.events.socket.ISocketListener;
import org.eclipse.ecf.filetransfer.identity.IFileID;
import org.eclipse.ecf.internal.tests.filetransfer.httpserver.SimpleServer;
import org.eclipse.ecf.provider.filetransfer.retrieve.AbstractRetrieveFileTransfer;
import org.eclipse.ecf.tests.filetransfer.SocketEventTestUtil.SocketInReadWrapper;
import org.eclipse.ecf.tests.filetransfer.SocketEventTestUtil.TrackSocketEvents;

public class URLRetrieveTestCancelConnectJob extends AbstractRetrieveTestCase {

	File tmpFile = null;
	private TrackSocketEvents socketEvents;
	private SocketInReadWrapper socketInReadWrapper;

	private boolean CANCEL_SUPPORTED_ON_CONNECT = new Boolean(
			System.getProperty(
					"org.eclipse.ecf.tests.filetransfer.cancelSupportedOnConnect",
					"true")).booleanValue();

	/*
	 * (non-Javadoc)
	 * 
	 * @see junit.framework.TestCase#setUp()
	 */
	protected void setUp() throws Exception {
		super.setUp();
	}

	protected void createTempFile() throws IOException {
		tmpFile = File.createTempFile("ECFTest", "");
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see junit.framework.TestCase#tearDown()
	 */
	protected void tearDown() throws Exception {
		super.tearDown();
		if (tmpFile != null)
			tmpFile.delete();
		tmpFile = null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ecf.tests.filetransfer.AbstractRetrieveTestCase#
	 * handleStartConnectEvent
	 * (org.eclipse.ecf.filetransfer.events.IFileTransferConnectStartEvent)
	 */
	protected void handleStartConnectEvent(IFileTransferConnectStartEvent event) {
		super.handleStartConnectEvent(event);
		this.socketEvents = SocketEventTestUtil.observeSocketEvents(event);
		ISocketEventSource source = (ISocketEventSource) event
				.getAdapter(ISocketEventSource.class);
		source.addListener(new ISocketListener() {

			public void handleSocketEvent(ISocketEvent event) {
				if (event instanceof ISocketConnectedEvent) {
					ISocketConnectedEvent connectedEvent = (ISocketConnectedEvent) event;
					socketInReadWrapper = new SocketInReadWrapper(
							connectedEvent.getSocket(), startTime);
					connectedEvent.setSocket(socketInReadWrapper);
				}
			}
		});

	}

	protected void handleDoneEvent(IIncomingFileTransferReceiveDoneEvent event) {
		super.handleDoneEvent(event);
		assertTrue(event.getSource().getException() instanceof UserCancelledException);
	}

	protected void testReceive(String url, IFileTransferListener listener)
			throws Exception {
		assertNotNull(retrieveAdapter);
		final IFileID fileID = createFileID(new URL(url));
		retrieveAdapter.sendRetrieveRequest(fileID, listener, null);
		waitForDone(10000);

	}

	public void testReceiveFile_cancelOnConnectEvent() throws Exception {
		if (!CANCEL_SUPPORTED_ON_CONNECT) {
			trace("WARNING:  Cancel not supported by this provider.  testReceiveFile_cancelOnConnectEvent cannot be used");
			return;
		}
		final IFileTransferListener listener = createFileTransferListener();
		final FileTransferListenerWrapper lw = new FileTransferListenerWrapper(
				listener) {
			protected void handleStartConnectEvent(
					IFileTransferConnectStartEvent event) {
				assertNotNull(event.getFileID());
				assertNotNull(event.getFileID().getFilename());
				assertNull(socketInReadWrapper);
				setDone(true);
				event.cancel();
			}
		};
		testReceive(URLRetrieveTest.HTTP_RETRIEVE, lw);

		assertHasEvent(startConnectEvents, IFileTransferConnectStartEvent.class);
		assertHasNoEvent(startEvents,
				IIncomingFileTransferReceiveStartEvent.class);
		assertHasNoEvent(dataEvents,
				IIncomingFileTransferReceiveDataEvent.class);
		assertDoneCancelled();

		assertNull(tmpFile);

		socketEvents.validateNoSocketCreated();

	}

	// TODO: add test that cancel without connect job, when server does not
	// respond
	public void testReceiveFile_cancelConnectJob() throws Exception {
		if (!CANCEL_SUPPORTED_ON_CONNECT) {
			trace("WARNING:  Cancel not supported by this provider.  testReceiveFile_cancelConnectJob cannot be used");
			return;
		}
		final Object[] doCancel = new Object[1];

		final IFileTransferListener listener = createFileTransferListener();
		final FileTransferListenerWrapper lw = new FileTransferListenerWrapper(
				listener) {
			protected void handleStartConnectEvent(
					final IFileTransferConnectStartEvent event) {
				assertNotNull(event.getFileID());
				assertNotNull(event.getFileID().getFilename());

				FileTransferJob connectJob = event.prepareConnectJob(null);
				connectJob.addJobChangeListener(new JobChangeTraceListener(
						startTime) {
					public void running(IJobChangeEvent jobEvent) {
						super.running(jobEvent);
						spawnCancelThread(doCancel, new ICancelable() {
							public void cancel() {
								assertNotNull(socketInReadWrapper);
								assertTrue(socketInReadWrapper.inRead);
								event.cancel();
							}
						});
					}
				});
				event.connectUsingJob(connectJob);
			}
		};

		final SimpleServer server = new SimpleServer(getName());
		SimpleHttpServer simple = server.getSimpleHttpServer();
		simple.setRequestHandler(new HttpRequestHandler() {

			public boolean processRequest(SimpleHttpServerConnection conn,
					SimpleRequest request) throws IOException {
				trace("Not responding to request " + request.getRequestLine());
				return stalledInRequestHandler(doCancel);
			}

		});
		try {
			// path does not matter as server does not respond.
			testReceive(server.getServerURL() + "/foo", lw);

			assertHasEvent(startConnectEvents,
					IFileTransferConnectStartEvent.class);
			assertHasNoEvent(startEvents,
					IIncomingFileTransferReceiveStartEvent.class);
			assertHasNoEvent(dataEvents,
					IIncomingFileTransferReceiveDataEvent.class);
			IIncomingFileTransferReceiveDoneEvent doneEvent = getDoneEvent();
			assertTrue(doneEvent.getException().toString(),
					doneEvent.getException() instanceof UserCancelledException);
			assertTrue(doneEvent.getSource().isDone());
			assertSame(doneEvent.getException(), doneEvent.getSource()
					.getException());

			assertNull(tmpFile);

			assertFalse(socketInReadWrapper.inRead);
			socketEvents.validateOneSocketCreatedAndClosed();

		} finally {
			server.shutdown();
		}
	}

	private static void writeLines(ResponseWriter w, String[] lines)
			throws IOException {
		for (int i = 0; i < lines.length; i++) {
			w.println(lines[i]);
		}
	}

	public void testReceiveFile_cancelTransferJob() throws Exception {
		if (!CANCEL_SUPPORTED_ON_CONNECT) {
			trace("WARNING:  Cancel not supported by this provider.  testReceiveFile_cancelTransferJob cannot be used");
			return;
		}
		final Object[] doCancel = new Object[1];

		final IFileTransferListener listener = createFileTransferListener();
		final FileTransferListenerWrapper lw = new FileTransferListenerWrapper(
				listener) {
			protected void handleStartConnectEvent(
					final IFileTransferConnectStartEvent event) {
				assertNotNull(event.getFileID());
				assertNotNull(event.getFileID().getFilename());

				FileTransferJob connectJob = event.prepareConnectJob(null);
				connectJob.addJobChangeListener(new JobChangeTraceListener(
						startTime));
				event.connectUsingJob(connectJob);
			}

			protected void handleStartEvent(
					final IIncomingFileTransferReceiveStartEvent event) {
				spawnCancelThread(doCancel, new ICancelable() {
					public void cancel() {
						waitForSocketInRead();
						assertNotNull(socketInReadWrapper);
						assertTrue(socketInReadWrapper.inRead);
						event.cancel();
					}

				});
				try {
					createTempFile();
					event.receive(tmpFile);
				} catch (IOException e) {
					e.printStackTrace();
					fail(e.toString());
				}
			}
		};

		final SimpleServer server = new SimpleServer(getName());
		SimpleHttpServer simple = server.getSimpleHttpServer();
		simple.setRequestHandler(new HttpRequestHandler() {

			public boolean processRequest(SimpleHttpServerConnection conn,
					SimpleRequest request) throws IOException {
				trace("Responding to request but never provide full body"
						+ request.getRequestLine());
				ResponseWriter w = conn.getWriter();
				writeLines(w, new String[] { "HTTP/1.0 200 OK",
						"Content-Length: 9",
						"Content-Type: text/plain; charset=UTF-8", "" });
				w.flush();
				synchronized (doCancel) {
					doCancel[0] = Boolean.TRUE;
				}

				conn.setKeepAlive(true);
				//
				return stalledInRequestHandler(doCancel);
			}

		});
		try {
			// path does not matter as server does not respond.
			testReceive(server.getServerURL() + "/foo", lw);

			assertHasEvent(startConnectEvents,
					IFileTransferConnectStartEvent.class);
			assertHasEvent(startEvents,
					IIncomingFileTransferReceiveStartEvent.class);
			assertDoneCancelled();

			assertNotNull(tmpFile);
			assertTrue(tmpFile.exists());
			assertEquals(0, tmpFile.length());

			assertFalse(socketInReadWrapper.inRead);
			socketEvents.validateOneSocketCreatedAndClosed();
		} finally {
			server.shutdown();
		}
	}

	private void waitForSocketInRead() {
		assertNotNull(socketInReadWrapper);
		while (!socketInReadWrapper.inRead) {
			try {
				Thread.sleep(0);
			} catch (InterruptedException e) {
			}
		}
		assertTrue(socketInReadWrapper.inRead);
	}

	public void testReceiveFile_cancelTransferJobAfterOneBlock()
			throws Exception {
		if (!CANCEL_SUPPORTED_ON_CONNECT) {
			trace("WARNING:  Cancel not supported by this provider.  testReceiveFile_cancelTransferJobAfterOneBlock cannot be used");
			return;
		}
		testReceiveFile_cancelTransferJobInMiddle(
				AbstractRetrieveFileTransfer.DEFAULT_BUF_LENGTH * 2, false);
	}

	public void testReceiveFile_cancelTransferJobInMiddle() throws Exception {
		if (!CANCEL_SUPPORTED_ON_CONNECT) {
			trace("WARNING:  Cancel not supported by this provider.  testReceiveFile_cancelTransferJobInMiddle cannot be used");
			return;
		}
		testReceiveFile_cancelTransferJobInMiddle(20000, true);
	}

	public void testReceiveFile_cancelTransferJobInMiddle(final long len,
			final boolean expectedSocketInRead) throws Exception {
		if (!CANCEL_SUPPORTED_ON_CONNECT) {
			trace("WARNING:  Cancel not supported by this provider.  testReceiveFile_cancelTransferJobInMiddle cannot be used");
			return;
		}
		final Object[] doCancel = new Object[1];

		final IFileTransferListener listener = createFileTransferListener();
		final FileTransferListenerWrapper lw = new FileTransferListenerWrapper(
				listener) {
			protected void handleStartConnectEvent(
					final IFileTransferConnectStartEvent event) {
				assertNotNull(event.getFileID());
				assertNotNull(event.getFileID().getFilename());

				FileTransferJob connectJob = event.prepareConnectJob(null);
				connectJob.addJobChangeListener(new JobChangeTraceListener(
						startTime));
				event.connectUsingJob(connectJob);
			}

			protected void handleStartEvent(
					final IIncomingFileTransferReceiveStartEvent event) {
				spawnCancelThread(doCancel, new ICancelable() {
					public void cancel() {
						if (expectedSocketInRead) {
							waitForSocketInRead();
						}
						event.cancel();
					}
				});
				try {
					createTempFile();
					event.receive(tmpFile);
				} catch (IOException e) {
					e.printStackTrace();
					fail(e.toString());
				}

			}
		};

		final SimpleServer server = new SimpleServer(getName());
		SimpleHttpServer simple = server.getSimpleHttpServer();
		simple.setRequestHandler(new HttpRequestHandler() {

			public boolean processRequest(SimpleHttpServerConnection conn,
					SimpleRequest request) throws IOException {
				trace("Responding to request but never provide only 50% of body"
						+ request.getRequestLine());
				ResponseWriter w = conn.getWriter();
				writeLines(w, new String[] { "HTTP/1.0 200 OK",
						"Content-Length: " + len,
						"Content-Type: text/plain; charset=UTF-8", "" });
				w.flush();
				for (int i = 0; i < len / 2; i++) {
					w.write("x");
				}
				w.flush();
				conn.setKeepAlive(true);
				try {
					// give it a bit of time to receive the data
					Thread.sleep(200);
				} catch (InterruptedException e) {
				}
				return stalledInRequestHandler(doCancel);
			}

		});
		try {
			// path does not matter as server does not respond.
			testReceive(server.getServerURL() + "/foo", lw);

			assertHasEvent(startConnectEvents,
					IFileTransferConnectStartEvent.class);
			assertHasEvent(startEvents,
					IIncomingFileTransferReceiveStartEvent.class);
			assertHasMoreThanEventCount(dataEvents,
					IIncomingFileTransferReceiveDataEvent.class, 0);
			assertDoneCancelled();

			assertNotNull(tmpFile);
			assertTrue(tmpFile.exists());
			assertEquals(len / 2, tmpFile.length());

			assertFalse(socketInReadWrapper.inRead);
			socketEvents.validateOneSocketCreatedAndClosed();

		} finally {
			server.shutdown();
		}
	}

	private boolean stalledInRequestHandler(final Object[] doCancel) {
		Exception ex = null;
		try {
			synchronized (doCancel) {
				doCancel[0] = Boolean.TRUE;
				doCancel.wait();
			}
		} catch (InterruptedException e) {
			// expected on shutdown.
			ex = e;
		}
		trace("Leaving request handler");
		assertTrue(ex instanceof InterruptedException);
		return false;
	}

	interface ICancelable {
		void cancel();
	}

	private void spawnCancelThread(final Object[] doCancel,
			final ICancelable cancelable) {
		Thread t = new Thread(new Runnable() {
			public void run() {
				trace("Cancel runnable started");
				while (true) {
					boolean cancel = false;
					synchronized (doCancel) {
						cancel = doCancel[0] != null;
					}
					if (cancel) {
						trace("Before calling cancel");
						cancelable.cancel();
						trace("After calling cancel");
						break;
					}
					try {
						Thread.sleep(200);
					} catch (InterruptedException e) {
						break;
					}
				}
				trace("Cancel runnable ending");
			}

		});
		t.start();
	}

}