examples/org.eclipse.ocl.examples.debug.vm/src/org/eclipse/ocl/examples/debug/vm/core/VMDebugTarget.java - ocl/org.eclipse.ocl - Git at Google

 /*******************************************************************************
  * Copyright (c) 2014, 2018 Willink Transformations and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v20.html
  *
  * Contributors:
  *     R.Dvorak and others - QVTo debugger framework
  *     E.D.Willink - revised API for OCL debugger framework
  *******************************************************************************/
 package org.eclipse.ocl.examples.debug.vm.core;

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.core.resources.IMarker;
 import org.eclipse.core.resources.IMarkerDelta;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.debug.core.DebugEvent;
 import org.eclipse.debug.core.DebugException;
 import org.eclipse.debug.core.DebugPlugin;
 import org.eclipse.debug.core.IBreakpointManager;
 import org.eclipse.debug.core.IBreakpointManagerListener;
 import org.eclipse.debug.core.IDebugEventSetListener;
 import org.eclipse.debug.core.ILaunch;
 import org.eclipse.debug.core.IStatusHandler;
 import org.eclipse.debug.core.model.IBreakpoint;
 import org.eclipse.debug.core.model.IDebugTarget;
 import org.eclipse.debug.core.model.IMemoryBlock;
 import org.eclipse.debug.core.model.IProcess;
 import org.eclipse.debug.core.model.IThread;
 import org.eclipse.debug.core.model.IValue;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.ocl.examples.debug.vm.BreakpointError;
 import org.eclipse.ocl.examples.debug.vm.IVMVirtualMachineShell;
 import org.eclipse.ocl.examples.debug.vm.VMEventListener;
 import org.eclipse.ocl.examples.debug.vm.VMVirtualMachine;
 import org.eclipse.ocl.examples.debug.vm.data.VMNewBreakpointData;
 import org.eclipse.ocl.examples.debug.vm.data.VMSuspension;
 import org.eclipse.ocl.examples.debug.vm.event.VMDisconnectEvent;
 import org.eclipse.ocl.examples.debug.vm.event.VMEvent;
 import org.eclipse.ocl.examples.debug.vm.event.VMResumeEvent;
 import org.eclipse.ocl.examples.debug.vm.event.VMStartEvent;
 import org.eclipse.ocl.examples.debug.vm.event.VMSuspendEvent;
 import org.eclipse.ocl.examples.debug.vm.event.VMTerminateEvent;
 import org.eclipse.ocl.examples.debug.vm.request.VMBreakpointRequest;
 import org.eclipse.ocl.examples.debug.vm.request.VMRequest;
 import org.eclipse.ocl.examples.debug.vm.request.VMResumeRequest;
 import org.eclipse.ocl.examples.debug.vm.request.VMStartRequest;
 import org.eclipse.ocl.examples.debug.vm.request.VMSuspendRequest;
 import org.eclipse.ocl.examples.debug.vm.request.VMTerminateRequest;
 import org.eclipse.ocl.examples.debug.vm.response.VMBreakpointResponse;
 import org.eclipse.ocl.examples.debug.vm.response.VMResponse;
 import org.eclipse.ocl.examples.debug.vm.utils.DebugOptions;
 import org.eclipse.ocl.pivot.utilities.ClassUtil;

 public abstract class VMDebugTarget extends VMDebugElement implements IVMDebugTarget, IDebugEventSetListener, IBreakpointManagerListener {

 	private final Map<Long, VMLineBreakpoint> fID2Breakpoint = new HashMap<Long, VMLineBreakpoint>();

 	private final ILaunch fLaunch;

 	private final IProcess fProcess;

 	private VMThread fMainThread;

 	private String fMainModuleName;

 	private boolean fIsStarting;
 	private boolean fIsSuspended = false;

 	private final IVMVirtualMachineShell fVM;
 	private final List<VMEventListener> fEventListener = new LinkedList<VMEventListener>();

 	private final Object fVMStartMonitor = new Object();
 	private Thread eventDispatcherThread;

 	public VMDebugTarget(IProcess process, IVMVirtualMachineShell vm) {
 		super(null);

 		fLaunch = process.getLaunch();
 		fProcess = process;
 		fVM = vm;
 		fIsStarting = true;
 		fEventListener.add(createVMEventListener());

 		EventDispatchJob dispatcher = new EventDispatchJob();
 		eventDispatcherThread = new Thread(dispatcher, getDebugCore().getDebugThreadName());
 		eventDispatcherThread.setDaemon(true);
 		eventDispatcherThread.start();

 		try {
 			// start transformation execution
 			sendRequest(new VMStartRequest(true));
 		} catch (DebugException e) {
 			getDebugCore().log(e.getStatus());
 			// FIXME - consult status handler to give UI feedback
 			return;
 		}

 		joinStartOrTerminate();
 		// Note: VM is still suspended and waiting for resume
 		// => do whatever initialization we need now
 		// install VM breakpoints
 		installVMBreakpoints();

 		DebugEvent createEvent = new DebugEvent(this, DebugEvent.CREATE);
 		createEvent.setData(new HashMap<Long, VMLineBreakpoint>(fID2Breakpoint));

 		fMainThread = new VMThread(this);
 		fLaunch.addDebugTarget(this);
 		System.setProperty(getDebugCore().getDebuggerActiveProperty(), Boolean.TRUE.toString());

 		try {
 			// wake up so far suspended VM unless suspendOnStart
 			if (!fIsSuspended) {
 				fVM.sendRequest(new VMResumeRequest(VMSuspension.UNSPECIFIED));
 			}
 		} catch (IOException e) {
 			getDebugCore().log(e);
 		}

 		IBreakpointManager breakpointManager = DebugPlugin.getDefault().getBreakpointManager();
 		breakpointManager.addBreakpointManagerListener(this);
 		breakpointManager.addBreakpointListener(this);
 		DebugPlugin.getDefault().addDebugEventListener(this);

 		fireEvent(createEvent);
 	}

 	protected @NonNull URI computeBreakpointURI(@NonNull URI sourceURI) {
 		return sourceURI;
 	}

 	private void installVMBreakpoints() {
 		HashMap<Long, VMLineBreakpoint> installedBreakpoints = new HashMap<>();
 		List<@NonNull VMNewBreakpointData> allBpData = new ArrayList<>();

 		for (@NonNull VMLineBreakpoint vmBp : getDebugCore().getLineBreakpoints()) {
 			boolean enabled = false;
 			try {
 				enabled = vmBp.isEnabled();
 			} catch (CoreException e) {
 				getDebugCore().log(e.getStatus());
 			}

 			if (enabled) {
 				installedBreakpoints.put(Long.valueOf(vmBp.getID()),
 						vmBp);
 				try {
 					String unitURI = vmBp.getUnitURI().toString();
 					@SuppressWarnings("null")@NonNull String targetURI = computeBreakpointURI(ClassUtil.nonNullEMF(URI.createURI(unitURI, true))).toString();
 					VMNewBreakpointData data = vmBp.createNewBreakpointData(targetURI);

 					allBpData.add(data);
 				} catch (CoreException e) {
 					getDebugCore().log(e.getStatus());
 				}
 			}
 		}

 		if (!allBpData.isEmpty()) {
 			@SuppressWarnings("null")@NonNull VMNewBreakpointData @NonNull [] bpData = allBpData.toArray(new VMNewBreakpointData[allBpData.size()]);
 			VMBreakpointRequest breakpointRequest = VMBreakpointRequest.createAdd(bpData);
 			try {
 				VMResponse response = fVM.sendRequest(breakpointRequest);
 				//
 				fID2Breakpoint.clear();
 				if(response instanceof VMBreakpointResponse) {
 					VMBreakpointResponse bpResponse = (VMBreakpointResponse) response;

 					for(long addedID : bpResponse.getAddedBreakpointsIDs()) {
 						Long key = Long.valueOf(addedID);
 						VMLineBreakpoint bp = installedBreakpoints.get(key);
 						if(bp != null) {
 							fID2Breakpoint.put(key, bp);
 						}
 					}
 				}
 			} catch (IOException e) {
 				getDebugCore().log(e);
 			}
 		}
 	}

 	public Collection<? extends IBreakpoint> getInstalledBreakpoints() {
 		return Collections.unmodifiableCollection(fID2Breakpoint.values());
 	}

 	@Override
 	public VMResponse sendRequest(@NonNull VMRequest request) throws DebugException {
 		try {
 			VMResponse response = fVM.sendRequest(request);
 			return response;
 		} catch (IOException e) {
 			throw new DebugException(getDebugCore().createDebugError("Send debug request failed", e));
 		}
 	}

 	@Override
 	public synchronized boolean isSuspended() {
 		return !isTerminated() && fIsSuspended;
 	}

 	@Override
 	public IDebugTarget getDebugTarget() {
 		return this;
 	}

 	@Override
 	public ILaunch getLaunch() {
 		return fLaunch;
 	}

 	public IVMVirtualMachineShell getVM() {
 		return fVM;
 	}

 	@Override
 	public IProcess getProcess() {
 		IProcess[] processes = getLaunch().getProcesses();
 		if (processes != null && processes.length > 0) {
 			return processes[0];
 		}

 		return null;
 	}

 	@Override
 	public boolean hasThreads() throws DebugException {
 		return !isTerminated();
 	}

 	@Override
 	public IThread[] getThreads() throws DebugException {
 		return (fMainThread != null) ? new IThread[] { fMainThread }
 		: new IThread[0];
 	}

 	@Override
 	public @NonNull String getName() {
 		return getDebugCore().getDebugTargetName();
 	}

 	@Override
 	public boolean supportsBreakpoint(IBreakpoint breakpoint) {
 		return breakpoint.getModelIdentifier().equals(getModelIdentifier());
 	}

 	@Override
 	public boolean canTerminate() {
 		return !isTerminated();
 	}

 	@Override
 	public boolean isTerminated() {
 		return fVM.isTerminated();
 	}

 	/**
 	 * This very brute force methhod is solely to clean up at the end of a test.
 	 *
 	 * It does not seem necessary when using JUnit plugin testing. But it helps for Tycho.
 	 */
 	@SuppressWarnings("deprecation")
 	public void killAfterTest() {
 		if ((fMainThread != null) && !fMainThread.isTerminated()) {
 			try {
 				fMainThread.terminate();
 			} catch (DebugException e) {
 				// TODO Auto-generated catch block
 				e.printStackTrace();
 			}
 			fMainThread = null;
 		}
 		if ((eventDispatcherThread != null) && eventDispatcherThread.isAlive()) {
 			eventDispatcherThread.stop();
 			eventDispatcherThread = null;
 		}
 	}

 	@Override
 	public void terminate() throws DebugException {
 		sendRequest(new VMTerminateRequest());
 	}

 	protected void started(String mainModuleName) {
 		setMainModuleName(mainModuleName);
 		setStarting(false);
 	}

 	synchronized protected void setMainModuleName(String mainModuleName) {
 		fMainModuleName = mainModuleName;
 	}

 	synchronized public String getMainModuleName() {
 		return fMainModuleName;
 	}

 	protected void terminated() {
 		getDebugCore().getTrace().trace(DebugOptions.TARGET, "Debug target terminated"); //$NON-NLS-1$
 		System.setProperty(getDebugCore().getDebuggerActiveProperty(), Boolean.FALSE.toString());

 		setStarting(false);

 		fMainThread = null;

 		DebugPlugin debugPlugin = DebugPlugin.getDefault();
 		if (debugPlugin != null) {
 			IBreakpointManager breakpointManager = debugPlugin.getBreakpointManager();
 			breakpointManager.removeBreakpointListener(this);
 			breakpointManager.removeBreakpointManagerListener(this);

 			debugPlugin.removeDebugEventListener(this);
 		}

 		fID2Breakpoint.clear();

 		fireTerminateEvent();
 		if (fProcess instanceof VMVirtualProcess) {
 			VMVirtualProcess vp = (VMVirtualProcess) fProcess;
 			vp.terminated();
 		}
 	}

 	@Override
 	public boolean canResume() {
 		return !isTerminated() && isSuspended();
 	}

 	@Override
 	public boolean canSuspend() {
 		return !isTerminated() && !isSuspended();
 	}

 	@Override
 	public void resume() throws DebugException {
 		sendRequest(new VMResumeRequest(VMSuspension.UNSPECIFIED));
 	}

 	@Override
 	public void suspend() throws DebugException {
 		sendRequest(new VMSuspendRequest(VMSuspension.UNSPECIFIED));
 	}

 	@Override
 	public void breakpointAdded(IBreakpoint breakpoint) {
 		if (breakpoint instanceof VMLineBreakpoint == false
 				|| !DebugPlugin.getDefault().getBreakpointManager().isEnabled()) {
 			return;
 		}

 		VMLineBreakpoint vmBreakpoint = (VMLineBreakpoint) breakpoint;
 		try {
 			VMNewBreakpointData bpData = vmBreakpoint.createNewBreakpointData();
 			VMBreakpointRequest addBreakpointRequest = VMBreakpointRequest.createAdd(bpData);

 			VMResponse response = sendRequest(addBreakpointRequest);
 			if(response instanceof VMBreakpointResponse) {
 				VMBreakpointResponse bpResponse = (VMBreakpointResponse) response;
 				long[] addedIDs = bpResponse.getAddedBreakpointsIDs();
 				if(addedIDs.length > 0) {
 					fID2Breakpoint.put(Long.valueOf(addedIDs[0]), vmBreakpoint);
 				}
 			}
 		} catch (CoreException e) {
 			getDebugCore().log(e.getStatus());
 		}
 	}

 	@Override
 	public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
 		if (breakpoint instanceof VMLineBreakpoint == false
 				|| !DebugPlugin.getDefault().getBreakpointManager().isEnabled()) {
 			return;
 		}

 		boolean nowEnabled = false;
 		try {
 			nowEnabled = breakpoint.isEnabled();
 		} catch (CoreException e1) {
 			// do nothing
 		}
 		boolean beforeEnabled = delta.getAttribute(IBreakpoint.ENABLED, false);

 		VMBreakpointRequest changeRequest = null;
 		try {
 			VMLineBreakpoint vmBreakpoint = (VMLineBreakpoint) breakpoint;
 			if (nowEnabled && !beforeEnabled) {
 				// just to be added to VM
 				changeRequest = VMBreakpointRequest.createAdd(new @NonNull VMNewBreakpointData[] { vmBreakpoint.createNewBreakpointData() });
 			} else if (!nowEnabled && beforeEnabled) {
 				// just to be removed from VM
 				changeRequest = VMBreakpointRequest.createRemove(vmBreakpoint.getID());
 			} else {
 				// modify existing data
 				changeRequest = VMBreakpointRequest.createChange(vmBreakpoint.getID(), vmBreakpoint.createBreakpointData());
 			}

 		} catch (CoreException e) {
 			getDebugCore().log(e);
 		}

 		if (changeRequest != null) {
 			try {
 				fVM.sendRequest(changeRequest);
 			} catch (IOException e) {
 				getDebugCore().log(e);
 			}
 		}
 	}

 	@Override
 	public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
 		if (breakpoint instanceof VMLineBreakpoint) {
 			if (delta == null) {
 				IMarker marker = breakpoint.getMarker();
 				if (marker.exists()) {
 					try {
 						marker.delete();
 					} catch (CoreException e) {
 						// TODO Auto-generated catch block
 						e.printStackTrace();
 					}
 				}
 			}
 			VMLineBreakpoint vmBreakpoint = (VMLineBreakpoint) breakpoint;
 			fID2Breakpoint.remove(Long.valueOf(((VMLineBreakpoint) breakpoint)
 					.getID()));

 			VMBreakpointRequest removeRequest = VMBreakpointRequest
 					.createRemove(vmBreakpoint.getID());
 			try {
 				fVM.sendRequest(removeRequest);
 			} catch (IOException e) {
 				getDebugCore().log(e);
 			}
 		}
 	}

 	@Override
 	public boolean canDisconnect() {
 		return false;
 	}

 	@Override
 	public void disconnect() throws DebugException {
 	}

 	@Override
 	public boolean isDisconnected() {
 		return false;
 	}

 	@Override
 	public boolean supportsStorageRetrieval() {
 		return false;
 	}

 	@Override
 	public IMemoryBlock getMemoryBlock(long startAddress, long length) throws DebugException {
 		return null;
 	}

 	@Override
 	public void handleDebugEvents(DebugEvent[] events) {
 		for (int i = 0; i < events.length; i++) {
 			DebugEvent event = events[i];

 			if (event.getKind() == DebugEvent.TERMINATE) {
 				// respond
 				if ((fMainThread != null && event.getSource() == fMainThread)
 						|| (event.getSource() == fProcess)) {
 					if(!isTerminated()) {
 						terminated();
 					}
 				}
 			}
 		}
 	}

 	@Override
 	public void breakpointManagerEnablementChanged(boolean enabled) {
 		for (IBreakpoint breakpoint : getDebugCore().getOCLBreakpoints(IBreakpoint.class)) {
 			if (enabled) {
 				breakpointAdded(breakpoint);
 			} else {
 				breakpointRemoved(breakpoint, null);
 			}
 		}
 	}

 	private void joinStartOrTerminate() {
 		synchronized (fVMStartMonitor) {
 			while(fIsStarting) {
 				try {
 					// wait until we receive VM startup event
 					fVMStartMonitor.wait();
 				} catch (InterruptedException e) {
 					Thread.interrupted();
 				}
 			}
 		}
 	}


 	private void setStarting(boolean isStarting) {
 		synchronized (fVMStartMonitor) {
 			fIsStarting = isStarting;
 			fVMStartMonitor.notify();
 		}
 	}

 	private void handleBreakpointConditionError(VMSuspendEvent suspend) {
 		IStatus breakpointStatus = new BreakpointError(suspend
 				.getBreakpointID(), suspend.getReason(),
 				suspend.getReasonDetail());

 		IStatusHandler handler = DebugPlugin.getDefault().getStatusHandler(breakpointStatus);
 		if(handler != null) {
 			try {
 				handler.handleStatus(breakpointStatus, VMDebugTarget.this);
 			} catch (CoreException e) {
 				getDebugCore().log(e.getStatus());
 			}
 		} else {
 			// no custom handler found, at least log the status
 			getDebugCore().log(breakpointStatus);
 		}
 	}

 	private VMEventListener createVMEventListener() {
 		return new VMEventListener() {

 			@Override
 			public void handleEvent(VMEvent event) {
 				if (event instanceof VMResumeEvent) {
 					fIsSuspended = false;
 					fireResumeEvent(0);
 				} else if (event instanceof VMSuspendEvent) {
 					fIsSuspended = true;

 					VMSuspendEvent suspend = (VMSuspendEvent) event;
 					fireSuspendEvent(suspend.suspension.getDebugEventDetail());

 					if (suspend.suspension == VMSuspension.BREAKPOINT_CONDITION_ERR) {
 						handleBreakpointConditionError(suspend);
 					}

 				} else if (event instanceof VMTerminateEvent) {
 					fIsSuspended = false;
 					terminated();
 				} else if (event instanceof VMDisconnectEvent) {
 					fIsSuspended = false;
 					terminated();
 				} else if (event instanceof VMStartEvent) {
 					VMStartEvent startEvent = (VMStartEvent) event;
 					started(startEvent.mainModuleName);
 					fIsSuspended = startEvent.suspendOnStartup;
 					if (fIsSuspended) {
 						fireSuspendEvent(VMSuspension.STEP_INTO.getDebugEventDetail());
 					}
 				}
 			}

 		};
 	}

 	@Override
 	public void addVMEventListener(@NonNull VMEventListener listener) {
 		synchronized (fEventListener) {
 			fEventListener.add(listener);
 		}
 	}

 	@Override
 	public boolean removeVMEventListener(@NonNull VMEventListener listener) {
 		synchronized (fEventListener) {
 			return fEventListener.remove(listener);
 		}
 	}

 	void handleVMEvent(VMEvent event) {
 		List<VMEventListener> listeners;
 		synchronized (fEventListener) {
 			listeners = new ArrayList<VMEventListener>(fEventListener);
 		}

 		for (VMEventListener vmEventListener : listeners) {
 			try {
 				vmEventListener.handleEvent(event);
 			} catch (Exception e) {
 				getDebugCore().log(e);
 			}
 		}
 	}

 	public IValue evaluate(@NonNull String expressionText, long frameID) throws CoreException {
 		if (getVM() instanceof VMVirtualMachine) {
 			return ((VMVirtualMachine) getVM()).evaluate(expressionText, this, frameID);
 		}
 		return null;
 	}

 	private class EventDispatchJob implements Runnable {

 		EventDispatchJob() {
 			super();
 		}

 		@Override
 		public void run() {
 			while (!isTerminated()) {
 				VMEvent event;
 				try {
 					event = fVM.readVMEvent();
 				} catch (IOException e) {
 					break;
 				}
 				if (VMVirtualMachine.VM_EVENT.isActive()) {
 					VMVirtualMachine.VM_EVENT.println(">[" + Thread.currentThread().getName() + "] " + event);
 				}
 				if (event != null) {
 					handleVMEvent(event);
 				}
 			}

 			getDebugCore().getTrace().trace(DebugOptions.TARGET,
 					"Debug target VMEvent dispatcher shutdown"); //$NON-NLS-1$
 		}
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2014, 2018 Willink Transformations and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v2.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v20.html
	*
	* Contributors:
	* R.Dvorak and others - QVTo debugger framework
	* E.D.Willink - revised API for OCL debugger framework
	*******************************************************************************/
	package org.eclipse.ocl.examples.debug.vm.core;

	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.core.resources.IMarker;
	import org.eclipse.core.resources.IMarkerDelta;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.debug.core.DebugEvent;
	import org.eclipse.debug.core.DebugException;
	import org.eclipse.debug.core.DebugPlugin;
	import org.eclipse.debug.core.IBreakpointManager;
	import org.eclipse.debug.core.IBreakpointManagerListener;
	import org.eclipse.debug.core.IDebugEventSetListener;
	import org.eclipse.debug.core.ILaunch;
	import org.eclipse.debug.core.IStatusHandler;
	import org.eclipse.debug.core.model.IBreakpoint;
	import org.eclipse.debug.core.model.IDebugTarget;
	import org.eclipse.debug.core.model.IMemoryBlock;
	import org.eclipse.debug.core.model.IProcess;
	import org.eclipse.debug.core.model.IThread;
	import org.eclipse.debug.core.model.IValue;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.jdt.annotation.NonNull;
	import org.eclipse.ocl.examples.debug.vm.BreakpointError;
	import org.eclipse.ocl.examples.debug.vm.IVMVirtualMachineShell;
	import org.eclipse.ocl.examples.debug.vm.VMEventListener;
	import org.eclipse.ocl.examples.debug.vm.VMVirtualMachine;
	import org.eclipse.ocl.examples.debug.vm.data.VMNewBreakpointData;
	import org.eclipse.ocl.examples.debug.vm.data.VMSuspension;
	import org.eclipse.ocl.examples.debug.vm.event.VMDisconnectEvent;
	import org.eclipse.ocl.examples.debug.vm.event.VMEvent;
	import org.eclipse.ocl.examples.debug.vm.event.VMResumeEvent;
	import org.eclipse.ocl.examples.debug.vm.event.VMStartEvent;
	import org.eclipse.ocl.examples.debug.vm.event.VMSuspendEvent;
	import org.eclipse.ocl.examples.debug.vm.event.VMTerminateEvent;
	import org.eclipse.ocl.examples.debug.vm.request.VMBreakpointRequest;
	import org.eclipse.ocl.examples.debug.vm.request.VMRequest;
	import org.eclipse.ocl.examples.debug.vm.request.VMResumeRequest;
	import org.eclipse.ocl.examples.debug.vm.request.VMStartRequest;
	import org.eclipse.ocl.examples.debug.vm.request.VMSuspendRequest;
	import org.eclipse.ocl.examples.debug.vm.request.VMTerminateRequest;
	import org.eclipse.ocl.examples.debug.vm.response.VMBreakpointResponse;
	import org.eclipse.ocl.examples.debug.vm.response.VMResponse;
	import org.eclipse.ocl.examples.debug.vm.utils.DebugOptions;
	import org.eclipse.ocl.pivot.utilities.ClassUtil;

	public abstract class VMDebugTarget extends VMDebugElement implements IVMDebugTarget, IDebugEventSetListener, IBreakpointManagerListener {

	private final Map<Long, VMLineBreakpoint> fID2Breakpoint = new HashMap<Long, VMLineBreakpoint>();

	private final ILaunch fLaunch;

	private final IProcess fProcess;

	private VMThread fMainThread;

	private String fMainModuleName;

	private boolean fIsStarting;
	private boolean fIsSuspended = false;

	private final IVMVirtualMachineShell fVM;
	private final List<VMEventListener> fEventListener = new LinkedList<VMEventListener>();

	private final Object fVMStartMonitor = new Object();
	private Thread eventDispatcherThread;

	public VMDebugTarget(IProcess process, IVMVirtualMachineShell vm) {
	super(null);

	fLaunch = process.getLaunch();
	fProcess = process;
	fVM = vm;
	fIsStarting = true;
	fEventListener.add(createVMEventListener());

	EventDispatchJob dispatcher = new EventDispatchJob();
	eventDispatcherThread = new Thread(dispatcher, getDebugCore().getDebugThreadName());
	eventDispatcherThread.setDaemon(true);
	eventDispatcherThread.start();

	try {
	// start transformation execution
	sendRequest(new VMStartRequest(true));
	} catch (DebugException e) {
	getDebugCore().log(e.getStatus());
	// FIXME - consult status handler to give UI feedback
	return;
	}

	joinStartOrTerminate();
	// Note: VM is still suspended and waiting for resume
	// => do whatever initialization we need now
	// install VM breakpoints
	installVMBreakpoints();

	DebugEvent createEvent = new DebugEvent(this, DebugEvent.CREATE);
	createEvent.setData(new HashMap<Long, VMLineBreakpoint>(fID2Breakpoint));

	fMainThread = new VMThread(this);
	fLaunch.addDebugTarget(this);
	System.setProperty(getDebugCore().getDebuggerActiveProperty(), Boolean.TRUE.toString());

	try {
	// wake up so far suspended VM unless suspendOnStart
	if (!fIsSuspended) {
	fVM.sendRequest(new VMResumeRequest(VMSuspension.UNSPECIFIED));
	}
	} catch (IOException e) {
	getDebugCore().log(e);
	}

	IBreakpointManager breakpointManager = DebugPlugin.getDefault().getBreakpointManager();
	breakpointManager.addBreakpointManagerListener(this);
	breakpointManager.addBreakpointListener(this);
	DebugPlugin.getDefault().addDebugEventListener(this);

	fireEvent(createEvent);
	}

	protected @NonNull URI computeBreakpointURI(@NonNull URI sourceURI) {
	return sourceURI;
	}

	private void installVMBreakpoints() {
	HashMap<Long, VMLineBreakpoint> installedBreakpoints = new HashMap<>();
	List<@NonNull VMNewBreakpointData> allBpData = new ArrayList<>();

	for (@NonNull VMLineBreakpoint vmBp : getDebugCore().getLineBreakpoints()) {
	boolean enabled = false;
	try {
	enabled = vmBp.isEnabled();
	} catch (CoreException e) {
	getDebugCore().log(e.getStatus());
	}

	if (enabled) {
	installedBreakpoints.put(Long.valueOf(vmBp.getID()),
	vmBp);
	try {
	String unitURI = vmBp.getUnitURI().toString();
	@SuppressWarnings("null")@NonNull String targetURI = computeBreakpointURI(ClassUtil.nonNullEMF(URI.createURI(unitURI, true))).toString();
	VMNewBreakpointData data = vmBp.createNewBreakpointData(targetURI);

	allBpData.add(data);
	} catch (CoreException e) {
	getDebugCore().log(e.getStatus());
	}
	}
	}

	if (!allBpData.isEmpty()) {
	@SuppressWarnings("null")@NonNull VMNewBreakpointData @NonNull [] bpData = allBpData.toArray(new VMNewBreakpointData[allBpData.size()]);
	VMBreakpointRequest breakpointRequest = VMBreakpointRequest.createAdd(bpData);
	try {
	VMResponse response = fVM.sendRequest(breakpointRequest);
	//
	fID2Breakpoint.clear();
	if(response instanceof VMBreakpointResponse) {
	VMBreakpointResponse bpResponse = (VMBreakpointResponse) response;

	for(long addedID : bpResponse.getAddedBreakpointsIDs()) {
	Long key = Long.valueOf(addedID);
	VMLineBreakpoint bp = installedBreakpoints.get(key);
	if(bp != null) {
	fID2Breakpoint.put(key, bp);
	}
	}
	}
	} catch (IOException e) {
	getDebugCore().log(e);
	}
	}
	}

	public Collection<? extends IBreakpoint> getInstalledBreakpoints() {
	return Collections.unmodifiableCollection(fID2Breakpoint.values());
	}

	@Override
	public VMResponse sendRequest(@NonNull VMRequest request) throws DebugException {
	try {
	VMResponse response = fVM.sendRequest(request);
	return response;
	} catch (IOException e) {
	throw new DebugException(getDebugCore().createDebugError("Send debug request failed", e));
	}
	}

	@Override
	public synchronized boolean isSuspended() {
	return !isTerminated() && fIsSuspended;
	}

	@Override
	public IDebugTarget getDebugTarget() {
	return this;
	}

	@Override
	public ILaunch getLaunch() {
	return fLaunch;
	}

	public IVMVirtualMachineShell getVM() {
	return fVM;
	}

	@Override
	public IProcess getProcess() {
	IProcess[] processes = getLaunch().getProcesses();
	if (processes != null && processes.length > 0) {
	return processes[0];
	}

	return null;
	}

	@Override
	public boolean hasThreads() throws DebugException {
	return !isTerminated();
	}

	@Override
	public IThread[] getThreads() throws DebugException {
	return (fMainThread != null) ? new IThread[] { fMainThread }
	: new IThread[0];
	}

	@Override
	public @NonNull String getName() {
	return getDebugCore().getDebugTargetName();
	}

	@Override
	public boolean supportsBreakpoint(IBreakpoint breakpoint) {
	return breakpoint.getModelIdentifier().equals(getModelIdentifier());
	}

	@Override
	public boolean canTerminate() {
	return !isTerminated();
	}

	@Override
	public boolean isTerminated() {
	return fVM.isTerminated();
	}

	/**
	* This very brute force methhod is solely to clean up at the end of a test.
	*
	* It does not seem necessary when using JUnit plugin testing. But it helps for Tycho.
	*/
	@SuppressWarnings("deprecation")
	public void killAfterTest() {
	if ((fMainThread != null) && !fMainThread.isTerminated()) {
	try {
	fMainThread.terminate();
	} catch (DebugException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
	}
	fMainThread = null;
	}
	if ((eventDispatcherThread != null) && eventDispatcherThread.isAlive()) {
	eventDispatcherThread.stop();
	eventDispatcherThread = null;
	}
	}

	@Override
	public void terminate() throws DebugException {
	sendRequest(new VMTerminateRequest());
	}

	protected void started(String mainModuleName) {
	setMainModuleName(mainModuleName);
	setStarting(false);
	}

	synchronized protected void setMainModuleName(String mainModuleName) {
	fMainModuleName = mainModuleName;
	}

	synchronized public String getMainModuleName() {
	return fMainModuleName;
	}

	protected void terminated() {
	getDebugCore().getTrace().trace(DebugOptions.TARGET, "Debug target terminated"); //$NON-NLS-1$
	System.setProperty(getDebugCore().getDebuggerActiveProperty(), Boolean.FALSE.toString());

	setStarting(false);

	fMainThread = null;

	DebugPlugin debugPlugin = DebugPlugin.getDefault();
	if (debugPlugin != null) {
	IBreakpointManager breakpointManager = debugPlugin.getBreakpointManager();
	breakpointManager.removeBreakpointListener(this);
	breakpointManager.removeBreakpointManagerListener(this);

	debugPlugin.removeDebugEventListener(this);
	}

	fID2Breakpoint.clear();

	fireTerminateEvent();
	if (fProcess instanceof VMVirtualProcess) {
	VMVirtualProcess vp = (VMVirtualProcess) fProcess;
	vp.terminated();
	}
	}

	@Override
	public boolean canResume() {
	return !isTerminated() && isSuspended();
	}

	@Override
	public boolean canSuspend() {
	return !isTerminated() && !isSuspended();
	}

	@Override
	public void resume() throws DebugException {
	sendRequest(new VMResumeRequest(VMSuspension.UNSPECIFIED));
	}

	@Override
	public void suspend() throws DebugException {
	sendRequest(new VMSuspendRequest(VMSuspension.UNSPECIFIED));
	}

	@Override
	public void breakpointAdded(IBreakpoint breakpoint) {
	if (breakpoint instanceof VMLineBreakpoint == false
	\|\| !DebugPlugin.getDefault().getBreakpointManager().isEnabled()) {
	return;
	}

	VMLineBreakpoint vmBreakpoint = (VMLineBreakpoint) breakpoint;
	try {
	VMNewBreakpointData bpData = vmBreakpoint.createNewBreakpointData();
	VMBreakpointRequest addBreakpointRequest = VMBreakpointRequest.createAdd(bpData);

	VMResponse response = sendRequest(addBreakpointRequest);
	if(response instanceof VMBreakpointResponse) {
	VMBreakpointResponse bpResponse = (VMBreakpointResponse) response;
	long[] addedIDs = bpResponse.getAddedBreakpointsIDs();
	if(addedIDs.length > 0) {
	fID2Breakpoint.put(Long.valueOf(addedIDs[0]), vmBreakpoint);
	}
	}
	} catch (CoreException e) {
	getDebugCore().log(e.getStatus());
	}
	}

	@Override
	public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
	if (breakpoint instanceof VMLineBreakpoint == false
	\|\| !DebugPlugin.getDefault().getBreakpointManager().isEnabled()) {
	return;
	}

	boolean nowEnabled = false;
	try {
	nowEnabled = breakpoint.isEnabled();
	} catch (CoreException e1) {
	// do nothing
	}
	boolean beforeEnabled = delta.getAttribute(IBreakpoint.ENABLED, false);

	VMBreakpointRequest changeRequest = null;
	try {
	VMLineBreakpoint vmBreakpoint = (VMLineBreakpoint) breakpoint;
	if (nowEnabled && !beforeEnabled) {
	// just to be added to VM
	changeRequest = VMBreakpointRequest.createAdd(new @NonNull VMNewBreakpointData[] { vmBreakpoint.createNewBreakpointData() });
	} else if (!nowEnabled && beforeEnabled) {
	// just to be removed from VM
	changeRequest = VMBreakpointRequest.createRemove(vmBreakpoint.getID());
	} else {
	// modify existing data
	changeRequest = VMBreakpointRequest.createChange(vmBreakpoint.getID(), vmBreakpoint.createBreakpointData());
	}

	} catch (CoreException e) {
	getDebugCore().log(e);
	}

	if (changeRequest != null) {
	try {
	fVM.sendRequest(changeRequest);
	} catch (IOException e) {
	getDebugCore().log(e);
	}
	}
	}

	@Override
	public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
	if (breakpoint instanceof VMLineBreakpoint) {
	if (delta == null) {
	IMarker marker = breakpoint.getMarker();
	if (marker.exists()) {
	try {
	marker.delete();
	} catch (CoreException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
	}
	}
	}
	VMLineBreakpoint vmBreakpoint = (VMLineBreakpoint) breakpoint;
	fID2Breakpoint.remove(Long.valueOf(((VMLineBreakpoint) breakpoint)
	.getID()));

	VMBreakpointRequest removeRequest = VMBreakpointRequest
	.createRemove(vmBreakpoint.getID());
	try {
	fVM.sendRequest(removeRequest);
	} catch (IOException e) {
	getDebugCore().log(e);
	}
	}
	}

	@Override
	public boolean canDisconnect() {
	return false;
	}

	@Override
	public void disconnect() throws DebugException {
	}

	@Override
	public boolean isDisconnected() {
	return false;
	}

	@Override
	public boolean supportsStorageRetrieval() {
	return false;
	}

	@Override
	public IMemoryBlock getMemoryBlock(long startAddress, long length) throws DebugException {
	return null;
	}

	@Override
	public void handleDebugEvents(DebugEvent[] events) {
	for (int i = 0; i < events.length; i++) {
	DebugEvent event = events[i];

	if (event.getKind() == DebugEvent.TERMINATE) {
	// respond
	if ((fMainThread != null && event.getSource() == fMainThread)
	\|\| (event.getSource() == fProcess)) {
	if(!isTerminated()) {
	terminated();
	}
	}
	}
	}
	}

	@Override
	public void breakpointManagerEnablementChanged(boolean enabled) {
	for (IBreakpoint breakpoint : getDebugCore().getOCLBreakpoints(IBreakpoint.class)) {
	if (enabled) {
	breakpointAdded(breakpoint);
	} else {
	breakpointRemoved(breakpoint, null);
	}
	}
	}

	private void joinStartOrTerminate() {
	synchronized (fVMStartMonitor) {
	while(fIsStarting) {
	try {
	// wait until we receive VM startup event
	fVMStartMonitor.wait();
	} catch (InterruptedException e) {
	Thread.interrupted();
	}
	}
	}
	}


	private void setStarting(boolean isStarting) {
	synchronized (fVMStartMonitor) {
	fIsStarting = isStarting;
	fVMStartMonitor.notify();
	}
	}

	private void handleBreakpointConditionError(VMSuspendEvent suspend) {
	IStatus breakpointStatus = new BreakpointError(suspend
	.getBreakpointID(), suspend.getReason(),
	suspend.getReasonDetail());

	IStatusHandler handler = DebugPlugin.getDefault().getStatusHandler(breakpointStatus);
	if(handler != null) {
	try {
	handler.handleStatus(breakpointStatus, VMDebugTarget.this);
	} catch (CoreException e) {
	getDebugCore().log(e.getStatus());
	}
	} else {
	// no custom handler found, at least log the status
	getDebugCore().log(breakpointStatus);
	}
	}

	private VMEventListener createVMEventListener() {
	return new VMEventListener() {

	@Override
	public void handleEvent(VMEvent event) {
	if (event instanceof VMResumeEvent) {
	fIsSuspended = false;
	fireResumeEvent(0);
	} else if (event instanceof VMSuspendEvent) {
	fIsSuspended = true;

	VMSuspendEvent suspend = (VMSuspendEvent) event;
	fireSuspendEvent(suspend.suspension.getDebugEventDetail());

	if (suspend.suspension == VMSuspension.BREAKPOINT_CONDITION_ERR) {
	handleBreakpointConditionError(suspend);
	}

	} else if (event instanceof VMTerminateEvent) {
	fIsSuspended = false;
	terminated();
	} else if (event instanceof VMDisconnectEvent) {
	fIsSuspended = false;
	terminated();
	} else if (event instanceof VMStartEvent) {
	VMStartEvent startEvent = (VMStartEvent) event;
	started(startEvent.mainModuleName);
	fIsSuspended = startEvent.suspendOnStartup;
	if (fIsSuspended) {
	fireSuspendEvent(VMSuspension.STEP_INTO.getDebugEventDetail());
	}
	}
	}

	};
	}

	@Override
	public void addVMEventListener(@NonNull VMEventListener listener) {
	synchronized (fEventListener) {
	fEventListener.add(listener);
	}
	}

	@Override
	public boolean removeVMEventListener(@NonNull VMEventListener listener) {
	synchronized (fEventListener) {
	return fEventListener.remove(listener);
	}
	}

	void handleVMEvent(VMEvent event) {
	List<VMEventListener> listeners;
	synchronized (fEventListener) {
	listeners = new ArrayList<VMEventListener>(fEventListener);
	}

	for (VMEventListener vmEventListener : listeners) {
	try {
	vmEventListener.handleEvent(event);
	} catch (Exception e) {
	getDebugCore().log(e);
	}
	}
	}

	public IValue evaluate(@NonNull String expressionText, long frameID) throws CoreException {
	if (getVM() instanceof VMVirtualMachine) {
	return ((VMVirtualMachine) getVM()).evaluate(expressionText, this, frameID);
	}
	return null;
	}

	private class EventDispatchJob implements Runnable {

	EventDispatchJob() {
	super();
	}

	@Override
	public void run() {
	while (!isTerminated()) {
	VMEvent event;
	try {
	event = fVM.readVMEvent();
	} catch (IOException e) {
	break;
	}
	if (VMVirtualMachine.VM_EVENT.isActive()) {
	VMVirtualMachine.VM_EVENT.println(">[" + Thread.currentThread().getName() + "] " + event);
	}
	if (event != null) {
	handleVMEvent(event);
	}
	}

	getDebugCore().getTrace().trace(DebugOptions.TARGET,
	"Debug target VMEvent dispatcher shutdown"); //$NON-NLS-1$
	}
	}

	}