core/plugins/org.eclipse.dltk.launching/src/org/eclipse/dltk/launching/DebugSessionAcceptor.java

/*******************************************************************************
 * Copyright (c) 2009, 2016 xored software, Inc. 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:
 *     xored software, Inc. - initial API and Implementation (Alex Panchenko)
 *******************************************************************************/
package org.eclipse.dltk.launching;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.dltk.compiler.util.Util;
import org.eclipse.dltk.dbgp.IDbgpSession;
import org.eclipse.dltk.dbgp.IDbgpThreadAcceptor;
import org.eclipse.dltk.debug.core.model.IScriptDebugTargetListener;
import org.eclipse.dltk.internal.debug.core.model.ScriptDebugTarget;
import org.eclipse.dltk.internal.launching.DLTKLaunchingPlugin;

public class DebugSessionAcceptor
		implements IDbgpThreadAcceptor, IScriptDebugTargetListener {

	private static class NopLaunchStatusHandler
			implements ILaunchStatusHandlerExtension {

		@Override
		public void initialize(IDebugTarget target, IProgressMonitor monitor) {
			// empty
		}

		@Override
		public void updateElapsedTime(long elapsedTime) {
			// empty
		}

		@Override
		public void dispose() {
			// empty
		}

		@Override
		public boolean isCanceled() {
			return true;
		}

	}

	private final ScriptDebugTarget target;
	private IProgressMonitor parentMonitor;
	private boolean initialized = false;
	private boolean connected = false;
	private ILaunchStatusHandler statusHandler = null;

	public DebugSessionAcceptor(ScriptDebugTarget target,
			IProgressMonitor monitor) {
		this.target = target;
		this.parentMonitor = monitor;
		target.addListener(this);
		target.getDbgpService().registerAcceptor(target.getSessionId(), this);
	}

	/*
	 * @see IScriptDebugTargetListener#targetInitialized()
	 */
	@Override
	public void targetInitialized() {
		synchronized (this) {
			initialized = true;
			notify();
		}
	}

	@Override
	public void targetTerminating() {
		target.getDbgpService().unregisterAcceptor(target.getSessionId());
		disposeStatusHandler();
	}

	public void disposeStatusHandler() {
		if (statusHandler != null) {
			statusHandler.dispose();
			statusHandler = null;
		}
	}

	private static final int WAIT_CHUNK = 1000;

	public boolean waitConnection(final int timeout) throws CoreException {
		final SubProgressMonitor sub = new SubProgressMonitor(parentMonitor, 1);
		sub.beginTask(Util.EMPTY_STRING, timeout / WAIT_CHUNK);
		try {
			sub.setTaskName(Messages.DebugSessionAcceptor_waitConnection);
			final long start = System.currentTimeMillis();
			try {
				long waitStart = start;
				for (;;) {
					synchronized (this) {
						if (connected) {
							return true;
						}
					}
					if (target.isTerminated() || sub.isCanceled()) {
						break;
					}
					abortIfProcessTerminated();
					synchronized (this) {
						wait(WAIT_CHUNK);
					}
					final long now = System.currentTimeMillis();
					if (timeout != 0 && (now - start) > timeout) {
						if (statusHandler == null) {
							statusHandler = createStatusHandler();
						}
						if (statusHandler instanceof ILaunchStatusHandlerExtension
								&& ((ILaunchStatusHandlerExtension) statusHandler)
										.isCanceled()) {
							return false;
						}
						statusHandler.updateElapsedTime(now - start);
					}
					sub.worked((int) ((now - waitStart) / WAIT_CHUNK));
					waitStart = now;
				}
			} catch (InterruptedException e) {
				Thread.currentThread().interrupt();
			}
			return false;
		} finally {
			sub.done();
		}
	}

	private void abortIfProcessTerminated() throws CoreException {
		if (target.getProcess() != null && target.getProcess().isTerminated()) {
			throw new CoreException(new Status(IStatus.ERROR,
					DLTKLaunchingPlugin.PLUGIN_ID,
					ScriptLaunchConfigurationConstants.ERR_DEBUGGER_PROCESS_TERMINATED,
					LaunchingMessages.DebugSessionAcceptor_DebuggerUnexpectedlyTerminated,
					null));
		}
	}

	/**
	 * @return
	 */
	private ILaunchStatusHandler createStatusHandler() {
		final String extensionPointId = DLTKLaunchingPlugin.PLUGIN_ID
				+ ".launchStatusHandler"; //$NON-NLS-1$
		final IConfigurationElement[] elements = Platform.getExtensionRegistry()
				.getConfigurationElementsFor(extensionPointId);
		for (int i = 0; i < elements.length; ++i) {
			try {
				final ILaunchStatusHandler handler = (ILaunchStatusHandler) elements[i]
						.createExecutableExtension("class"); //$NON-NLS-1$
				handler.initialize(target, parentMonitor);
				return handler;
			} catch (Exception e) {
				DLTKLaunchingPlugin.logWarning(e);
			}
		}
		final ILaunchStatusHandler handler = new NopLaunchStatusHandler();
		handler.initialize(target, parentMonitor);
		return handler;
	}

	@Override
	public void acceptDbgpThread(IDbgpSession session,
			IProgressMonitor monitor) {
		final boolean isFirst;
		synchronized (this) {
			isFirst = !connected;
			if (!connected) {
				connected = true;
				notify();
			}
		}
		if (isFirst) {
			IProgressMonitor sub = getInitializeMonitor();
			try {
				target.getDbgpThreadAcceptor().acceptDbgpThread(session, sub);
			} finally {
				sub.done();
			}
		} else {
			target.getDbgpThreadAcceptor().acceptDbgpThread(session,
					new NullProgressMonitor());
		}
	}

	private IProgressMonitor initializeMonitor = null;

	private synchronized IProgressMonitor getInitializeMonitor() {
		if (initializeMonitor == null) {
			initializeMonitor = new SubProgressMonitor(parentMonitor, 1);
			initializeMonitor.beginTask(Util.EMPTY_STRING, 100);
			initializeMonitor.setTaskName(
					Messages.DebugSessionAcceptor_waitInitialization);
		}
		return initializeMonitor;
	}

	public boolean waitInitialized(final int timeout) throws CoreException {
		final IProgressMonitor sub = getInitializeMonitor();
		try {
			final long start = System.currentTimeMillis();
			try {
				for (;;) {
					synchronized (this) {
						if (initialized) {
							return true;
						}
					}
					if (target.isTerminated() || sub.isCanceled()) {
						break;
					}
					abortIfProcessTerminated();
					synchronized (this) {
						wait(WAIT_CHUNK);
					}
					final long now = System.currentTimeMillis();
					if (timeout != 0 && (now - start) > timeout) {
						break;
					}
				}
			} catch (InterruptedException e) {
				Thread.interrupted();
			}
			return false;
		} finally {
			sub.done();
		}
	}

}