bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/repository/TimeoutTest.java - equinox/rt.equinox.p2 - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009, 2017 Cloudsmith Inc. and others.
  * The code, documentation and other materials contained herein have been
  * licensed under the Eclipse Public License - v 1.0 by the copyright holder
  * listed above, as the Initial Contributor under such license. The text of
  * such license is available at www.eclipse.org.
  ******************************************************************************/

 package org.eclipse.equinox.p2.tests.repository;

 import java.io.ByteArrayOutputStream;
 import java.net.URI;
 import java.security.cert.Certificate;
 import org.eclipse.core.runtime.*;
 import org.eclipse.equinox.internal.p2.transport.ecf.RepositoryTransport;
 import org.eclipse.equinox.p2.core.ProvisionException;
 import org.eclipse.equinox.p2.core.UIServices;
 import org.eclipse.equinox.p2.tests.metadata.repository.AllServerTests;
 import org.eclipse.equinox.p2.tests.testserver.helper.AbstractTestServerClientCase;

 /**
  * Test handling of timeout in FileInfoReader and FileReader
  */
 public class TimeoutTest extends AbstractTestServerClientCase {
 	private static final int MODIFIED = 1;
 	private static final int DOWNLOAD = 2;
 	private static final int STREAM = 3;

 	protected String authTestFailMessage;

 	@Override
 	public void tearDown() throws Exception {
 		AllServerTests.setServiceUI(null); // cleanup hook
 		super.tearDown();
 	}

 	/**
 	 * Test that timeout occurs, that the expected exception is thrown, and with correct detail
 	 * and message.
 	 * Note that test takes at least 120 seconds to complete due to length of timeout.
 	 * @throws ProvisionException
 	 * @throws Exception
 	 */
 	public void doTimeout(int type) throws Exception {
 		System.out.print("Note that test takes at least 120 seconds before timing out\n");
 		AllServerTests.setServiceUI(new AladdinNotSavedService());
 		RepositoryTransport transport = new RepositoryTransport();
 		URI toDownload = new URI(getBaseURL() + "/timeout/whatever.txt");
 		long startTime = System.currentTimeMillis();
 		boolean caught = false;
 		try {
 			switch (type) {
 				case DOWNLOAD :
 					IStatus status = transport.download(toDownload, new ByteArrayOutputStream(), null);
 					assertSocketTimeout(status, null);
 					caught = true;
 					break;
 				case MODIFIED :
 					transport.getLastModified(toDownload, null);
 					break;
 				case STREAM :
 					transport.stream(toDownload, null);
 					break;
 			}
 		} catch (OperationCanceledException e) {
 			fail("The getLastModified was canceled - the UI auth service is probably not running");
 		} catch (CoreException e) {

 			IStatus status = e.getStatus();
 			assertSocketTimeout(status, e);
 			caught = true;
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 		long endTime = System.currentTimeMillis();
 		System.out.print("The timeout took:" + Long.valueOf((endTime - startTime) / 1000).toString() + "\n");
 		assertTrue("timeout should have been caught", caught);
 	}

 	private void assertSocketTimeout(IStatus status, Exception e) {
 		Throwable ex = status.getException();
 		String msg = e == null ? "" : e.getMessage();
 		if (ex instanceof CoreException)
 			msg = ((CoreException) ex).getStatus().getMessage();

 		// Print for human inspection
 		System.out.print(String.format("%s e-message: [%s], detail:[%s]\n", //
 				provisionCodeToText(status.getCode()), msg, ex != null ? ex.getMessage() : "<no detailed message>"));
 		assertEquals("Socket timeout exception should be found as detail", ex.getClass(), java.net.SocketTimeoutException.class);

 	}

 	/**
 	 * Test that timeout occurs, that the expected exception is thrown, and with correct detail
 	 * and message.
 	 * Note that test takes at least 120 seconds to complete due to length of timeout.
 	 * @throws ProvisionException
 	 * @throws Exception
 	 */
 	public void testInfoTimeout() throws Exception {
 		doTimeout(MODIFIED);
 	}

 	/**
 	 * Test that it is possible to cancel a repository load that hangs on a HEAD request.
 	 * Note that test takes at least 10 seconds (the cancel delay time). The real timeout is
 	 * 120 seconds.
 	 * @throws ProvisionException
 	 * @throws Exception
 	 */
 	public void testInfoTimeoutCancelation() throws Exception {
 		doTimeoutCancelation(MODIFIED);
 	}

 	public void testDownloadTimeout() throws Exception {
 		doTimeout(DOWNLOAD);
 	}

 	public void testDownloadTimeoutCancelation() throws Exception {
 		doTimeoutCancelation(DOWNLOAD);
 	}

 	public void testStreamTimeout() throws Exception {
 		doTimeout(STREAM);
 	}

 	public void testStreamTimeoutCancelation() throws Exception {
 		doTimeoutCancelation(STREAM);
 	}

 	public void doTimeoutCancelation(int type) throws Exception {
 		System.out.print("Note that test takes at least 10 seconds before timing out (and >120 if it fails)\n");

 		AllServerTests.setServiceUI(new AladdinNotSavedService());
 		RepositoryTransport transport = new RepositoryTransport();
 		URI toDownload = new URI(getBaseURL() + "/timeout/whatever.txt");

 		IProgressMonitor monitor = new NullProgressMonitor();
 		MonitorCancelation cancelHandler = new MonitorCancelation(monitor, 10000);
 		Thread proc = new Thread(cancelHandler, "cancelHandler");
 		proc.start();
 		boolean caught = false;
 		long startTime = System.currentTimeMillis();
 		try {
 			switch (type) {
 				case DOWNLOAD :
 					transport.download(toDownload, new ByteArrayOutputStream(), monitor);
 					break;
 				case MODIFIED :
 					transport.getLastModified(toDownload, monitor);
 					break;
 				case STREAM :
 					transport.stream(toDownload, monitor);
 					break;
 			}
 		} catch (OperationCanceledException e) {
 			caught = true;
 		} catch (CoreException e) {

 			IStatus status = e.getStatus();
 			Throwable ex = status.getException();
 			String msg = e.getMessage();
 			if (ex instanceof CoreException)
 				msg = ((CoreException) ex).getStatus().getMessage();

 			// Print for human inspection
 			System.out.print(String.format("%s e-message: [%s], detail:[%s]\n", //
 					provisionCodeToText(status.getCode()), msg, ex != null ? ex.getMessage() : "<no detailed message>"));
 			assertEquals("Socket exception (socket closed) should be found as detail", ex.getClass(), java.net.SocketException.class);
 			assertEquals("Exception message from SocketException", "Socket closed", ex.getMessage());
 			caught = true;

 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 		long endTime = System.currentTimeMillis();
 		assertTrue("The timeout should have been canceled", caught);
 		assertTrue("The cancel should happen before the timeout", endTime - startTime < 50000);

 		// ignore testing if repo was loaded - it may or may not, depending on where the cancellation took place.
 		// commented code kept, in case there is a change in API - should cancellation of load keep the repository.
 		// assertFalse("Repository should not have been added", mgr.contains(repoLoc));
 	}

 	private static String provisionCodeToText(int code) {
 		String msg = "REPOSITORY_";
 		switch (code) {
 			case ProvisionException.REPOSITORY_EXISTS :
 				return msg + "EXISTS";
 			case ProvisionException.REPOSITORY_FAILED_AUTHENTICATION :
 				return msg + "FAILED_AUTHENTICATION";
 			case ProvisionException.REPOSITORY_FAILED_READ :
 				return msg + "FAILED_READ";
 			case ProvisionException.REPOSITORY_FAILED_WRITE :
 				return msg + "FAILED_WRITE";
 			case ProvisionException.REPOSITORY_INVALID_LOCATION :
 				return msg + "INVALID_LOCATION";
 			case ProvisionException.REPOSITORY_NOT_FOUND :
 				return msg + "NOT_FOUND";
 			case ProvisionException.REPOSITORY_READ_ONLY :
 				return msg + "READ_ONLY";
 			case ProvisionException.REPOSITORY_UNKNOWN_TYPE :
 				return msg + "UNKNOWN_TYPE";
 			default :
 				return msg + String.format("<unrecognized error code: %d >", code);
 		}
 	}

 	public class AladdinNotSavedService extends UIServices {
 		public int counter = 0;

 		@Override
 		public AuthenticationInfo getUsernamePassword(String location) {
 			counter++;
 			return new AuthenticationInfo("Aladdin", "open sesame", false);
 		}

 		@Override
 		public AuthenticationInfo getUsernamePassword(String location, AuthenticationInfo previousInfo) {
 			counter++;
 			assertEquals("Aladdin", previousInfo.getUserName());
 			assertEquals("open sesame", previousInfo.getPassword());
 			assertEquals(false, previousInfo.saveResult());
 			return previousInfo;
 		}

 		/**
 		 * Not used
 		 */
 		@Override
 		public TrustInfo getTrustInfo(Certificate[][] untrustedChain, String[] unsignedDetail) {
 			return new TrustInfo(null, false, true);
 		}
 	}

 	public static class MonitorCancelation implements Runnable {
 		private IProgressMonitor theMonitor;
 		private long theDelay;

 		MonitorCancelation(IProgressMonitor monitor, long delay) {
 			theMonitor = monitor;
 			theDelay = delay;
 		}

 		@Override
 		public void run() {
 			try {
 				Thread.sleep(theDelay);
 			} catch (InterruptedException e) {
 				/* ignore */
 			}
 			System.out.print("TimeoutTest: Cancelling monitor\n");
 			theMonitor.setCanceled(true);

 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2009, 2017 Cloudsmith Inc. and others.
	* The code, documentation and other materials contained herein have been
	* licensed under the Eclipse Public License - v 1.0 by the copyright holder
	* listed above, as the Initial Contributor under such license. The text of
	* such license is available at www.eclipse.org.
	******************************************************************************/

	package org.eclipse.equinox.p2.tests.repository;

	import java.io.ByteArrayOutputStream;
	import java.net.URI;
	import java.security.cert.Certificate;
	import org.eclipse.core.runtime.*;
	import org.eclipse.equinox.internal.p2.transport.ecf.RepositoryTransport;
	import org.eclipse.equinox.p2.core.ProvisionException;
	import org.eclipse.equinox.p2.core.UIServices;
	import org.eclipse.equinox.p2.tests.metadata.repository.AllServerTests;
	import org.eclipse.equinox.p2.tests.testserver.helper.AbstractTestServerClientCase;

	/**
	* Test handling of timeout in FileInfoReader and FileReader
	*/
	public class TimeoutTest extends AbstractTestServerClientCase {
	private static final int MODIFIED = 1;
	private static final int DOWNLOAD = 2;
	private static final int STREAM = 3;

	protected String authTestFailMessage;

	@Override
	public void tearDown() throws Exception {
	AllServerTests.setServiceUI(null); // cleanup hook
	super.tearDown();
	}

	/**
	* Test that timeout occurs, that the expected exception is thrown, and with correct detail
	* and message.
	* Note that test takes at least 120 seconds to complete due to length of timeout.
	* @throws ProvisionException
	* @throws Exception
	*/
	public void doTimeout(int type) throws Exception {
	System.out.print("Note that test takes at least 120 seconds before timing out\n");
	AllServerTests.setServiceUI(new AladdinNotSavedService());
	RepositoryTransport transport = new RepositoryTransport();
	URI toDownload = new URI(getBaseURL() + "/timeout/whatever.txt");
	long startTime = System.currentTimeMillis();
	boolean caught = false;
	try {
	switch (type) {
	case DOWNLOAD :
	IStatus status = transport.download(toDownload, new ByteArrayOutputStream(), null);
	assertSocketTimeout(status, null);
	caught = true;
	break;
	case MODIFIED :
	transport.getLastModified(toDownload, null);
	break;
	case STREAM :
	transport.stream(toDownload, null);
	break;
	}
	} catch (OperationCanceledException e) {
	fail("The getLastModified was canceled - the UI auth service is probably not running");
	} catch (CoreException e) {

	IStatus status = e.getStatus();
	assertSocketTimeout(status, e);
	caught = true;
	} catch (Exception e) {
	e.printStackTrace();
	}
	long endTime = System.currentTimeMillis();
	System.out.print("The timeout took:" + Long.valueOf((endTime - startTime) / 1000).toString() + "\n");
	assertTrue("timeout should have been caught", caught);
	}

	private void assertSocketTimeout(IStatus status, Exception e) {
	Throwable ex = status.getException();
	String msg = e == null ? "" : e.getMessage();
	if (ex instanceof CoreException)
	msg = ((CoreException) ex).getStatus().getMessage();

	// Print for human inspection
	System.out.print(String.format("%s e-message: [%s], detail:[%s]\n", //
	provisionCodeToText(status.getCode()), msg, ex != null ? ex.getMessage() : "<no detailed message>"));
	assertEquals("Socket timeout exception should be found as detail", ex.getClass(), java.net.SocketTimeoutException.class);

	}

	/**
	* Test that timeout occurs, that the expected exception is thrown, and with correct detail
	* and message.
	* Note that test takes at least 120 seconds to complete due to length of timeout.
	* @throws ProvisionException
	* @throws Exception
	*/
	public void testInfoTimeout() throws Exception {
	doTimeout(MODIFIED);
	}

	/**
	* Test that it is possible to cancel a repository load that hangs on a HEAD request.
	* Note that test takes at least 10 seconds (the cancel delay time). The real timeout is
	* 120 seconds.
	* @throws ProvisionException
	* @throws Exception
	*/
	public void testInfoTimeoutCancelation() throws Exception {
	doTimeoutCancelation(MODIFIED);
	}

	public void testDownloadTimeout() throws Exception {
	doTimeout(DOWNLOAD);
	}

	public void testDownloadTimeoutCancelation() throws Exception {
	doTimeoutCancelation(DOWNLOAD);
	}

	public void testStreamTimeout() throws Exception {
	doTimeout(STREAM);
	}

	public void testStreamTimeoutCancelation() throws Exception {
	doTimeoutCancelation(STREAM);
	}

	public void doTimeoutCancelation(int type) throws Exception {
	System.out.print("Note that test takes at least 10 seconds before timing out (and >120 if it fails)\n");

	AllServerTests.setServiceUI(new AladdinNotSavedService());
	RepositoryTransport transport = new RepositoryTransport();
	URI toDownload = new URI(getBaseURL() + "/timeout/whatever.txt");

	IProgressMonitor monitor = new NullProgressMonitor();
	MonitorCancelation cancelHandler = new MonitorCancelation(monitor, 10000);
	Thread proc = new Thread(cancelHandler, "cancelHandler");
	proc.start();
	boolean caught = false;
	long startTime = System.currentTimeMillis();
	try {
	switch (type) {
	case DOWNLOAD :
	transport.download(toDownload, new ByteArrayOutputStream(), monitor);
	break;
	case MODIFIED :
	transport.getLastModified(toDownload, monitor);
	break;
	case STREAM :
	transport.stream(toDownload, monitor);
	break;
	}
	} catch (OperationCanceledException e) {
	caught = true;
	} catch (CoreException e) {

	IStatus status = e.getStatus();
	Throwable ex = status.getException();
	String msg = e.getMessage();
	if (ex instanceof CoreException)
	msg = ((CoreException) ex).getStatus().getMessage();

	// Print for human inspection
	System.out.print(String.format("%s e-message: [%s], detail:[%s]\n", //
	provisionCodeToText(status.getCode()), msg, ex != null ? ex.getMessage() : "<no detailed message>"));
	assertEquals("Socket exception (socket closed) should be found as detail", ex.getClass(), java.net.SocketException.class);
	assertEquals("Exception message from SocketException", "Socket closed", ex.getMessage());
	caught = true;

	} catch (Exception e) {
	e.printStackTrace();
	}
	long endTime = System.currentTimeMillis();
	assertTrue("The timeout should have been canceled", caught);
	assertTrue("The cancel should happen before the timeout", endTime - startTime < 50000);

	// ignore testing if repo was loaded - it may or may not, depending on where the cancellation took place.
	// commented code kept, in case there is a change in API - should cancellation of load keep the repository.
	// assertFalse("Repository should not have been added", mgr.contains(repoLoc));
	}

	private static String provisionCodeToText(int code) {
	String msg = "REPOSITORY_";
	switch (code) {
	case ProvisionException.REPOSITORY_EXISTS :
	return msg + "EXISTS";
	case ProvisionException.REPOSITORY_FAILED_AUTHENTICATION :
	return msg + "FAILED_AUTHENTICATION";
	case ProvisionException.REPOSITORY_FAILED_READ :
	return msg + "FAILED_READ";
	case ProvisionException.REPOSITORY_FAILED_WRITE :
	return msg + "FAILED_WRITE";
	case ProvisionException.REPOSITORY_INVALID_LOCATION :
	return msg + "INVALID_LOCATION";
	case ProvisionException.REPOSITORY_NOT_FOUND :
	return msg + "NOT_FOUND";
	case ProvisionException.REPOSITORY_READ_ONLY :
	return msg + "READ_ONLY";
	case ProvisionException.REPOSITORY_UNKNOWN_TYPE :
	return msg + "UNKNOWN_TYPE";
	default :
	return msg + String.format("<unrecognized error code: %d >", code);
	}
	}

	public class AladdinNotSavedService extends UIServices {
	public int counter = 0;

	@Override
	public AuthenticationInfo getUsernamePassword(String location) {
	counter++;
	return new AuthenticationInfo("Aladdin", "open sesame", false);
	}

	@Override
	public AuthenticationInfo getUsernamePassword(String location, AuthenticationInfo previousInfo) {
	counter++;
	assertEquals("Aladdin", previousInfo.getUserName());
	assertEquals("open sesame", previousInfo.getPassword());
	assertEquals(false, previousInfo.saveResult());
	return previousInfo;
	}

	/**
	* Not used
	*/
	@Override
	public TrustInfo getTrustInfo(Certificate[][] untrustedChain, String[] unsignedDetail) {
	return new TrustInfo(null, false, true);
	}
	}

	public static class MonitorCancelation implements Runnable {
	private IProgressMonitor theMonitor;
	private long theDelay;

	MonitorCancelation(IProgressMonitor monitor, long delay) {
	theMonitor = monitor;
	theDelay = delay;
	}

	@Override
	public void run() {
	try {
	Thread.sleep(theDelay);
	} catch (InterruptedException e) {
	/* ignore */
	}
	System.out.print("TimeoutTest: Cancelling monitor\n");
	theMonitor.setCanceled(true);

	}
	}
	}