Attachment #180190 for bug #326951

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




import org.eclipse.cdt.dsf.concurrent.IDsfStatusConstants;
import org.eclipse.cdt.dsf.concurrent.ImmediateExecutor;
import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
import org.eclipse.cdt.dsf.concurrent.RequestMonitorWithProgress;
import org.eclipse.cdt.dsf.concurrent.Sequence;
import org.eclipse.cdt.dsf.concurrent.ThreadSafe;
import org.eclipse.cdt.dsf.concurrent.ThreadSafeAndProhibitedFromDsfExecutor;

import org.eclipse.cdt.dsf.debug.service.command.ICommandControlService.ICommandControlShutdownDMEvent;
import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;
import org.eclipse.cdt.dsf.gdb.internal.memory.GdbMemoryBlockRetrieval;
import org.eclipse.cdt.dsf.gdb.launching.GdbServicesSequence.ServiceSequenceOperation;
import org.eclipse.cdt.dsf.gdb.service.command.IGDBControl;
import org.eclipse.cdt.dsf.mi.service.IMIProcesses;
import org.eclipse.cdt.dsf.mi.service.MIProcesses;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugEvent;

        }
        fShutDown = true;
            
        Sequence shutdownSeq = getServicesSequence(ServiceSequenceOperation.SHUTDOWN,
            new RequestMonitorWithProgress(fSession.getExecutor(), new NullProgressMonitor()) { 
            new RequestMonitor(fSession.getExecutor(), rm) { 
                @Override
                public void handleCompleted() {
                    fSession.removeServiceEventListener(GdbLaunch.this);

        Platform.getAdapterManager().loadAdapter(this, adapter.getName());
        return super.getAdapter(adapter);
    }
    
	/**
	 * This method can be overridden by subclasses to allow to change the services sequence.
	 * @since 4.0
	 */
	public Sequence getServicesSequence(ServiceSequenceOperation type, RequestMonitorWithProgress rm) {
		return new GdbServicesSequence(type, getSession(), this, rm);
	}
}




import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
import org.eclipse.cdt.dsf.concurrent.DsfExecutor;
import org.eclipse.cdt.dsf.concurrent.ImmediateExecutor;
import org.eclipse.cdt.dsf.concurrent.Query;
import org.eclipse.cdt.dsf.concurrent.RequestMonitorWithProgress;
import org.eclipse.cdt.dsf.concurrent.Sequence;
import org.eclipse.cdt.dsf.concurrent.ThreadSafe;
import org.eclipse.cdt.dsf.debug.service.IDsfDebugServicesFactory;
import org.eclipse.cdt.dsf.debug.sourcelookup.DsfSourceLookupDirector;
import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;
import org.eclipse.cdt.dsf.gdb.launching.GdbServicesSequence.ServiceSequenceOperation;
import org.eclipse.cdt.dsf.gdb.service.GdbDebugServicesFactory;
import org.eclipse.cdt.dsf.gdb.service.GdbDebugServicesFactoryNS;
import org.eclipse.cdt.dsf.gdb.service.SessionType;


        // Create and invoke the launch sequence to create the debug control and services
        IProgressMonitor subMon1 = new SubProgressMonitor(monitor, 4, SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK); 
        final Sequence servicesLaunchSequence =
        	launch.getServicesSequence(ServiceSequenceOperation.INITIALIZE,  new RequestMonitorWithProgress(ImmediateExecutor.getInstance(), subMon1));
        
        launch.getSession().getExecutor().execute(servicesLaunchSequence);
        try {




/*******************************************************************************
 * Copyright (c) 2006, 2010 Wind River Systems 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:
 *     Wind River Systems - initial API and implementation
 *     Nokia 			  - handled GDBBackend service. Sep. 2008
 *     IBM Corporation 
 *     Ericsson           - Support for Tracing Control service
 *     Ericsson           - Converted to use ReflectionSequence to allow for overriding
 *******************************************************************************/
package org.eclipse.cdt.dsf.gdb.launching;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.eclipse.cdt.debug.internal.core.sourcelookup.CSourceLookupDirector;
import org.eclipse.cdt.dsf.concurrent.ReflectionSequence;
import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
import org.eclipse.cdt.dsf.concurrent.RequestMonitorWithProgress;
import org.eclipse.cdt.dsf.debug.service.IBreakpoints;
import org.eclipse.cdt.dsf.debug.service.IDisassembly;
import org.eclipse.cdt.dsf.debug.service.IExpressions;
import org.eclipse.cdt.dsf.debug.service.IMemory;
import org.eclipse.cdt.dsf.debug.service.IModules;
import org.eclipse.cdt.dsf.debug.service.IProcesses;
import org.eclipse.cdt.dsf.debug.service.IRegisters;
import org.eclipse.cdt.dsf.debug.service.IRunControl;
import org.eclipse.cdt.dsf.debug.service.ISourceLookup;
import org.eclipse.cdt.dsf.debug.service.ISourceLookup.ISourceLookupDMContext;
import org.eclipse.cdt.dsf.debug.service.IStack;
import org.eclipse.cdt.dsf.debug.service.command.ICommandControlService;
import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;
import org.eclipse.cdt.dsf.gdb.service.IGDBTraceControl;
import org.eclipse.cdt.dsf.mi.service.CSourceLookup;
import org.eclipse.cdt.dsf.mi.service.IMIBackend;
import org.eclipse.cdt.dsf.mi.service.MIBreakpointsManager;
import org.eclipse.cdt.dsf.service.DsfServicesTracker;
import org.eclipse.cdt.dsf.service.DsfSession;
import org.eclipse.cdt.dsf.service.IDsfService;

/**
 * This class replaces both ServicesLaunchSequence and ShutdownSequence to
 * allow to easily override this functionality.  The two classes have been merged into
 * a single class since they are so closely related.
 * 
 * @since 4.0
 */
public class GdbServicesSequence extends ReflectionSequence {

	public enum ServiceSequenceOperation { INITIALIZE, SHUTDOWN };

	private final static String[] INITIALIZATION_STEPS = new String[] {
		"handleBackendService",   //$NON-NLS-1$
		"handleCommandControlService",   //$NON-NLS-1$
		"handleProcessesService",    //$NON-NLS-1$
		"handleRunControlService",   //$NON-NLS-1$
		"handleMemoryService",   //$NON-NLS-1$
		"handleModuleService",   //$NON-NLS-1$
		"handleStackService",   //$NON-NLS-1$
		"handleExpressionsService",   //$NON-NLS-1$
		"handleSourceLookupService",   //$NON-NLS-1$
		"handleBreakpointsService",   //$NON-NLS-1$
		"handleBreakpointsMediatorService",   //$NON-NLS-1$
		"handleRegistersService",   //$NON-NLS-1$
		"handleDisassemblyService",   //$NON-NLS-1$
		"handleTraceControlService",   //$NON-NLS-1$
	};

	private final ServiceSequenceOperation fOperation;
	private final DsfSession fSession;
	private final GdbLaunch fLaunch;

	private ICommandControlService fCommandControl;

	public GdbServicesSequence(ServiceSequenceOperation operation, DsfSession session, GdbLaunch launch, RequestMonitorWithProgress rm) {
		super(session.getExecutor(), rm, 
				   operation == ServiceSequenceOperation.INITIALIZE ? LaunchMessages.getString("ServicesLaunchSequence_0") : "",    //$NON-NLS-1$ //$NON-NLS-2$
				   operation == ServiceSequenceOperation.INITIALIZE ? LaunchMessages.getString("ServicesLaunchSequence_1") : "");   //$NON-NLS-1$ //$NON-NLS-2$
		fSession = session;
		fLaunch = launch;
		fOperation = operation;
	}

	@Override
	protected String[] getExecutionOrder(String group) {
		if (GROUP_TOP_LEVEL.equals(group)) {
			if (fOperation == ServiceSequenceOperation.INITIALIZE) {
				return INITIALIZATION_STEPS;
			} else {
				// Use the reverse order of the initialization sequence
				// We need to create a brand new array list or else we'll actually reverse the init_steps array.
				List<String> orderedList = new ArrayList<String>(Arrays.asList(INITIALIZATION_STEPS));
				Collections.reverse(orderedList);
				return orderedList.toArray(new String[orderedList.size()]);
			}
		}
		return null;
	}

	/** @since 4.0 */
	@Execute
	public void handleBackendService(RequestMonitor requestMonitor) {
		if (fOperation == ServiceSequenceOperation.INITIALIZE) {
			fLaunch.getServiceFactory().createService(IMIBackend.class, fSession, fLaunch.getLaunchConfiguration()).initialize(requestMonitor);
		} else {
	        shutdownService(IMIBackend.class, requestMonitor);
		}
	}

	/** @since 4.0 */
	@Execute
	public void handleCommandControlService(RequestMonitor requestMonitor) {
		if (fOperation == ServiceSequenceOperation.INITIALIZE) {
			fCommandControl = fLaunch.getServiceFactory().createService(ICommandControlService.class, fSession, fLaunch.getLaunchConfiguration());
			fCommandControl.initialize(requestMonitor);
		} else {
	        shutdownService(ICommandControlService.class, requestMonitor);
		}
	}

	/** @since 4.0 */
	@Execute
	public void handleProcessesService(RequestMonitor requestMonitor) {
		if (fOperation == ServiceSequenceOperation.INITIALIZE) {
			fLaunch.getServiceFactory().createService(IProcesses.class, fSession).initialize(requestMonitor);
		} else {
	        shutdownService(IProcesses.class, requestMonitor);
		}
	}

	/** @since 4.0 */
	@Execute
	public void handleRunControlService(RequestMonitor requestMonitor) {
		if (fOperation == ServiceSequenceOperation.INITIALIZE) {
			fLaunch.getServiceFactory().createService(IRunControl.class, fSession).initialize(requestMonitor);
		} else {
	        shutdownService(IRunControl.class, requestMonitor);
		}
	}

	/** @since 4.0 */
	@Execute
	public void handleMemoryService(RequestMonitor requestMonitor) {
		if (fOperation == ServiceSequenceOperation.INITIALIZE) {
			fLaunch.getServiceFactory().createService(IMemory.class, fSession).initialize(requestMonitor);
		} else {
	        shutdownService(IMemory.class, requestMonitor);
		}
	}

	/** @since 4.0 */
	@Execute
	public void handleModuleService(RequestMonitor requestMonitor) {
		if (fOperation == ServiceSequenceOperation.INITIALIZE) {
			fLaunch.getServiceFactory().createService(IModules.class, fSession).initialize(requestMonitor);
		} else {
	        shutdownService(IModules.class, requestMonitor);
		}
	}

	/** @since 4.0 */
	@Execute
	public void handleStackService(RequestMonitor requestMonitor) {
		if (fOperation == ServiceSequenceOperation.INITIALIZE) {
			fLaunch.getServiceFactory().createService(IStack.class, fSession).initialize(requestMonitor);
		} else {
	        shutdownService(IStack.class, requestMonitor);
		}
	}

	/** @since 4.0 */
	@Execute
	public void handleExpressionsService(RequestMonitor requestMonitor) {
		if (fOperation == ServiceSequenceOperation.INITIALIZE) {
			fLaunch.getServiceFactory().createService(IExpressions.class, fSession).initialize(requestMonitor);
		} else {
	        shutdownService(IExpressions.class, requestMonitor);
		}
	}

	/** @since 4.0 */
	@Execute
	public void handleSourceLookupService(final RequestMonitor requestMonitor) {
		if (fOperation == ServiceSequenceOperation.INITIALIZE) {
			final CSourceLookup sourceLookup = (CSourceLookup)fLaunch.getServiceFactory().createService(ISourceLookup.class, fSession);
			sourceLookup.initialize(new RequestMonitor(getExecutor(), requestMonitor) {
				@Override
				protected void handleSuccess() {
					ISourceLookupDMContext sourceLookupDmc = (ISourceLookupDMContext)fCommandControl.getContext();
					sourceLookup.setSourceLookupDirector(sourceLookupDmc, (CSourceLookupDirector)fLaunch.getSourceLocator());
					requestMonitor.done();
				}
			});
		} else {
	        shutdownService(ISourceLookup.class, requestMonitor);
		}
	}

	/** @since 4.0 */
	@Execute
	public void handleBreakpointsService(final RequestMonitor requestMonitor) {
		if (fOperation == ServiceSequenceOperation.INITIALIZE) {
			fLaunch.getServiceFactory().createService(IBreakpoints.class, fSession).initialize(new RequestMonitor(getExecutor(), requestMonitor));
		} else {
	        shutdownService(IBreakpoints.class, requestMonitor);
		}
	}

	/** @since 4.0 */
	@Execute
	public void handleBreakpointsMediatorService(final RequestMonitor requestMonitor) {
		if (fOperation == ServiceSequenceOperation.INITIALIZE) {
			fLaunch.getServiceFactory().createService(MIBreakpointsManager.class, fSession).initialize(new RequestMonitor(getExecutor(), requestMonitor)); 
		} else {
	        shutdownService(MIBreakpointsManager.class, requestMonitor);
		}
	}

	/** @since 4.0 */
	@Execute
	public void handleRegistersService(RequestMonitor requestMonitor) {
		if (fOperation == ServiceSequenceOperation.INITIALIZE) {
			fLaunch.getServiceFactory().createService(IRegisters.class, fSession).initialize(requestMonitor);
		} else {
	        shutdownService(IRegisters.class, requestMonitor);
		}
	}

	/** @since 4.0 */
	@Execute
	public void handleDisassemblyService(RequestMonitor requestMonitor) {
		if (fOperation == ServiceSequenceOperation.INITIALIZE) {
			fLaunch.getServiceFactory().createService(IDisassembly.class, fSession).initialize(requestMonitor);
		} else {
	        shutdownService(IDisassembly.class, requestMonitor);
		}
	}

	/** @since 4.0 */
	@Execute
	public void handleTraceControlService(RequestMonitor requestMonitor) {
		if (fOperation == ServiceSequenceOperation.INITIALIZE) {
			IGDBTraceControl traceService = fLaunch.getServiceFactory().createService(IGDBTraceControl.class, fSession, fLaunch.getLaunchConfiguration());
			// Note that for older versions of GDB, we don't support tracing, so there is no trace service.
			if (traceService != null) {
				traceService.initialize(requestMonitor);
			} else {
				requestMonitor.done();
			}
		} else {
	        shutdownService(IGDBTraceControl.class, requestMonitor);
		}
	}

    private <V extends IDsfService> void shutdownService(Class<V> clazz, final RequestMonitor requestMonitor) {
    	DsfServicesTracker tracker = new DsfServicesTracker(GdbPlugin.getBundleContext(), fSession.getId());
        IDsfService service = tracker.getService(clazz);
        tracker.dispose();
        if (service != null) {
            service.shutdown(new RequestMonitor(getExecutor(), requestMonitor) {
                @Override
                protected void handleCompleted() {
                    if (!isSuccess()) {
                        GdbPlugin.getDefault().getLog().log(getStatus());
                    }
                    requestMonitor.done();
                }
            });
        } else {
        	// It is possible that a particular service was not instantiated at all
        	// depending on our backend
            requestMonitor.done();
        }
    }
}




/*******************************************************************************
 * Copyright (c) 2006, 2010 Wind River Systems 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:
 *     Wind River Systems - initial API and implementation
 *     Nokia 			  - created GDBBackend service. Sep. 2008
 *     IBM Corporation 
 *     Ericsson           - Support for Tracing Control service
 *******************************************************************************/
package org.eclipse.cdt.dsf.gdb.launching;

import org.eclipse.cdt.debug.internal.core.sourcelookup.CSourceLookupDirector;
import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
import org.eclipse.cdt.dsf.concurrent.Sequence;
import org.eclipse.cdt.dsf.debug.service.IBreakpoints;
import org.eclipse.cdt.dsf.debug.service.IDisassembly;
import org.eclipse.cdt.dsf.debug.service.IExpressions;
import org.eclipse.cdt.dsf.debug.service.IMemory;
import org.eclipse.cdt.dsf.debug.service.IModules;
import org.eclipse.cdt.dsf.debug.service.IProcesses;
import org.eclipse.cdt.dsf.debug.service.IRegisters;
import org.eclipse.cdt.dsf.debug.service.IRunControl;
import org.eclipse.cdt.dsf.debug.service.ISourceLookup;
import org.eclipse.cdt.dsf.debug.service.IStack;
import org.eclipse.cdt.dsf.debug.service.ISourceLookup.ISourceLookupDMContext;
import org.eclipse.cdt.dsf.debug.service.command.ICommandControlService;
import org.eclipse.cdt.dsf.gdb.service.IGDBTraceControl;
import org.eclipse.cdt.dsf.mi.service.CSourceLookup;
import org.eclipse.cdt.dsf.mi.service.IMIBackend;
import org.eclipse.cdt.dsf.mi.service.IMIProcesses;
import org.eclipse.cdt.dsf.mi.service.MIBreakpointsManager;
import org.eclipse.cdt.dsf.service.DsfSession;
import org.eclipse.core.runtime.IProgressMonitor;

public class ServicesLaunchSequence extends Sequence {

    Step[] fSteps = new Step[] {
        new Step() { 
            @Override
            public void execute(RequestMonitor requestMonitor) {
                // Create the back end GDB service.
                //
                fLaunch.getServiceFactory().createService(IMIBackend.class, fSession, fLaunch.getLaunchConfiguration()).initialize(requestMonitor);
            }
        },
        // Create and initialize the Connection service.
        new Step() { 
            @Override
            public void execute(RequestMonitor requestMonitor) {
                //
                // Create the connection.
                //
                fCommandControl = fLaunch.getServiceFactory().createService(ICommandControlService.class, fSession, fLaunch.getLaunchConfiguration());
                fCommandControl.initialize(requestMonitor);
            }
        },
        new Step() { @Override
        public void execute(RequestMonitor requestMonitor) {
        	fProcService = (IMIProcesses)fLaunch.getServiceFactory().createService(IProcesses.class, fSession);
        	fProcService.initialize(requestMonitor);
        }},
        new Step() { @Override
        public void execute(RequestMonitor requestMonitor) {
        	fLaunch.getServiceFactory().createService(IRunControl.class, fSession).initialize(requestMonitor);
        }},
        new Step() { @Override
        public void execute(RequestMonitor requestMonitor) {
        	fLaunch.getServiceFactory().createService(IMemory.class, fSession).initialize(requestMonitor);
        }},
        new Step() { @Override
        public void execute(RequestMonitor requestMonitor) {
        	fLaunch.getServiceFactory().createService(IModules.class, fSession).initialize(requestMonitor);
        }},
        new Step() { @Override
        public void execute(RequestMonitor requestMonitor) {
        	fLaunch.getServiceFactory().createService(IStack.class, fSession).initialize(requestMonitor);
        }},
        new Step() { @Override
        public void execute(RequestMonitor requestMonitor) {
        	fLaunch.getServiceFactory().createService(IExpressions.class, fSession).initialize(requestMonitor);
        }},
        new Step() { @Override
        public void execute(RequestMonitor requestMonitor) {
        	fSourceLookup = (CSourceLookup)fLaunch.getServiceFactory().createService(ISourceLookup.class, fSession);
            fSourceLookup.initialize(requestMonitor);
        }},
        new Step() { @Override
        public void execute(RequestMonitor requestMonitor) {
       		ISourceLookupDMContext sourceLookupDmc = (ISourceLookupDMContext)fCommandControl.getContext();
            fSourceLookup.setSourceLookupDirector(sourceLookupDmc, (CSourceLookupDirector)fLaunch.getSourceLocator());
            requestMonitor.done();
        }},
        new Step() { @Override
        public void execute(final RequestMonitor requestMonitor) {
            // Create the low-level breakpoint service 
        	fLaunch.getServiceFactory().createService(IBreakpoints.class, fSession).initialize(new RequestMonitor(getExecutor(), requestMonitor));
        }},
        new Step() { @Override
        public void execute(final RequestMonitor requestMonitor) {
            // Create high-level breakpoint service and install breakpoints 
            // for the GDB debug context.
        	fLaunch.getServiceFactory().createService(MIBreakpointsManager.class, fSession).initialize(new RequestMonitor(getExecutor(), requestMonitor)); 
        }},
        new Step() { @Override
        public void execute(RequestMonitor requestMonitor) {
        	fLaunch.getServiceFactory().createService(IRegisters.class, fSession).initialize(requestMonitor);
        }},
        new Step() { @Override
        public void execute(RequestMonitor requestMonitor) {
        	fLaunch.getServiceFactory().createService(IDisassembly.class, fSession).initialize(requestMonitor);
        }},
        new Step() { @Override
        public void execute(RequestMonitor requestMonitor) {
           	IGDBTraceControl traceService = fLaunch.getServiceFactory().createService(IGDBTraceControl.class, fSession, fLaunch.getLaunchConfiguration());
           	// Note that for older versions of GDB, we don't support tracing, so there is no trace service.
           	if (traceService != null) {
           		traceService.initialize(requestMonitor);
           	} else {
           		requestMonitor.done();
           	}
        }},
    };

    DsfSession fSession;
    GdbLaunch fLaunch;

    ICommandControlService fCommandControl;
    IMIProcesses fProcService;
    CSourceLookup fSourceLookup;
    
    public ServicesLaunchSequence(DsfSession session, GdbLaunch launch, IProgressMonitor pm) {
        super(session.getExecutor(), pm, LaunchMessages.getString("ServicesLaunchSequence_0"), LaunchMessages.getString("ServicesLaunchSequence_1"));   //$NON-NLS-1$ //$NON-NLS-2$
        fSession = session;
        fLaunch = launch;
    }
    
    @Override
    public Step[] getSteps() {
        return fSteps;
    }
    


}




/*******************************************************************************
 * Copyright (c) 2006, 2010 Wind River Systems 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:
 *     Wind River Systems - initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.dsf.gdb.launching;

import org.eclipse.cdt.dsf.concurrent.DsfExecutor;
import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
import org.eclipse.cdt.dsf.concurrent.Sequence;
import org.eclipse.cdt.dsf.debug.service.IBreakpoints;
import org.eclipse.cdt.dsf.debug.service.IDisassembly;
import org.eclipse.cdt.dsf.debug.service.IExpressions;
import org.eclipse.cdt.dsf.debug.service.IMemory;
import org.eclipse.cdt.dsf.debug.service.IModules;
import org.eclipse.cdt.dsf.debug.service.IProcesses;
import org.eclipse.cdt.dsf.debug.service.IRegisters;
import org.eclipse.cdt.dsf.debug.service.IRunControl;
import org.eclipse.cdt.dsf.debug.service.ISourceLookup;
import org.eclipse.cdt.dsf.debug.service.IStack;
import org.eclipse.cdt.dsf.debug.service.command.ICommandControl;
import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;
import org.eclipse.cdt.dsf.gdb.service.IGDBTraceControl;
import org.eclipse.cdt.dsf.mi.service.IMIBackend;
import org.eclipse.cdt.dsf.mi.service.MIBreakpointsManager;
import org.eclipse.cdt.dsf.service.DsfServicesTracker;
import org.eclipse.cdt.dsf.service.IDsfService;

public class ShutdownSequence extends Sequence {

    String fSessionId;

    String fApplicationName;

    String fDebugModelId;

    DsfServicesTracker fTracker;

    public ShutdownSequence(DsfExecutor executor, String sessionId, RequestMonitor requestMonitor) {
        super(executor, requestMonitor);
        fSessionId = sessionId;
    }

    @Override
    public Step[] getSteps() {
        return fSteps;
    }

    private final Step[] fSteps = new Step[] { new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            assert GdbPlugin.getBundleContext() != null;
            fTracker = new DsfServicesTracker(GdbPlugin.getBundleContext(), fSessionId);
            requestMonitor.done();
        }

        @Override
        public void rollBack(RequestMonitor requestMonitor) {
            fTracker.dispose();
            fTracker = null;
            requestMonitor.done();
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            shutdownService(IGDBTraceControl.class, requestMonitor);
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            shutdownService(IDisassembly.class, requestMonitor);
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            shutdownService(IRegisters.class, requestMonitor);
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            shutdownService(MIBreakpointsManager.class, requestMonitor);
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            shutdownService(IBreakpoints.class, requestMonitor);
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            shutdownService(ISourceLookup.class, requestMonitor);
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            shutdownService(IExpressions.class, requestMonitor);
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            shutdownService(IStack.class, requestMonitor);
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            shutdownService(IModules.class, requestMonitor);
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            shutdownService(IMemory.class, requestMonitor);
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            shutdownService(IRunControl.class, requestMonitor);
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            shutdownService(IProcesses.class, requestMonitor);
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            shutdownService(ICommandControl.class, requestMonitor);
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            shutdownService(IMIBackend.class, requestMonitor);
        }
    }, new Step() {
        @Override
        public void execute(RequestMonitor requestMonitor) {
            fTracker.dispose();
            fTracker = null;
            requestMonitor.done();
        }
    } };

    @SuppressWarnings("unchecked")
    private void shutdownService(Class clazz, final RequestMonitor requestMonitor) {
        IDsfService service = (IDsfService)fTracker.getService(clazz);
        if (service != null) {
            service.shutdown(new RequestMonitor(getExecutor(), requestMonitor) {
                @Override
                protected void handleCompleted() {
                    if (!isSuccess()) {
                        GdbPlugin.getDefault().getLog().log(getStatus());
                    }
                    requestMonitor.done();
                }
            });
        } else {
        	// It is possible that a particular service was not instantiated at all
        	// depending on our backend
            requestMonitor.done();
        }
    }
}

Return to bug 326951

Lines 21-26 Link Here

(-)src/org/eclipse/cdt/dsf/gdb/launching/GdbLaunch.java (-3 / +13 lines)
21	import org.eclipse.cdt.dsf.concurrent.IDsfStatusConstants;	21	import org.eclipse.cdt.dsf.concurrent.IDsfStatusConstants;
22	import org.eclipse.cdt.dsf.concurrent.ImmediateExecutor;	22	import org.eclipse.cdt.dsf.concurrent.ImmediateExecutor;
23	import org.eclipse.cdt.dsf.concurrent.RequestMonitor;	23	import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
		24	import org.eclipse.cdt.dsf.concurrent.RequestMonitorWithProgress;
24	import org.eclipse.cdt.dsf.concurrent.Sequence;	25	import org.eclipse.cdt.dsf.concurrent.Sequence;
25	import org.eclipse.cdt.dsf.concurrent.ThreadSafe;	26	import org.eclipse.cdt.dsf.concurrent.ThreadSafe;
26	import org.eclipse.cdt.dsf.concurrent.ThreadSafeAndProhibitedFromDsfExecutor;	27	import org.eclipse.cdt.dsf.concurrent.ThreadSafeAndProhibitedFromDsfExecutor;
Lines 33-38 Link Here
33	import org.eclipse.cdt.dsf.debug.service.command.ICommandControlService.ICommandControlShutdownDMEvent;	34	import org.eclipse.cdt.dsf.debug.service.command.ICommandControlService.ICommandControlShutdownDMEvent;
34	import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;	35	import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;
35	import org.eclipse.cdt.dsf.gdb.internal.memory.GdbMemoryBlockRetrieval;	36	import org.eclipse.cdt.dsf.gdb.internal.memory.GdbMemoryBlockRetrieval;
		37	import org.eclipse.cdt.dsf.gdb.launching.GdbServicesSequence.ServiceSequenceOperation;
36	import org.eclipse.cdt.dsf.gdb.service.command.IGDBControl;	38	import org.eclipse.cdt.dsf.gdb.service.command.IGDBControl;
37	import org.eclipse.cdt.dsf.mi.service.IMIProcesses;	39	import org.eclipse.cdt.dsf.mi.service.IMIProcesses;
38	import org.eclipse.cdt.dsf.mi.service.MIProcesses;	40	import org.eclipse.cdt.dsf.mi.service.MIProcesses;
Lines 44-49 Link Here
44	import org.eclipse.core.runtime.CoreException;	46	import org.eclipse.core.runtime.CoreException;
45	import org.eclipse.core.runtime.IStatus;	47	import org.eclipse.core.runtime.IStatus;
46	import org.eclipse.core.runtime.MultiStatus;	48	import org.eclipse.core.runtime.MultiStatus;
		49	import org.eclipse.core.runtime.NullProgressMonitor;
47	import org.eclipse.core.runtime.Platform;	50	import org.eclipse.core.runtime.Platform;
48	import org.eclipse.core.runtime.Status;	51	import org.eclipse.core.runtime.Status;
49	import org.eclipse.debug.core.DebugEvent;	52	import org.eclipse.debug.core.DebugEvent;
Lines 264-272 Link Here
264	}	267	}
265	fShutDown = true;	268	fShutDown = true;
266		269
267	Sequence shutdownSeq = new ShutdownSequence(	270	Sequence shutdownSeq = getServicesSequence(ServiceSequenceOperation.SHUTDOWN,
268	getDsfExecutor(), fSession.getId(),	271	new RequestMonitorWithProgress(fSession.getExecutor(), new NullProgressMonitor()) {
269	new RequestMonitor(fSession.getExecutor(), rm) {
270	@Override	272	@Override
271	public void handleCompleted() {	273	public void handleCompleted() {
272	fSession.removeServiceEventListener(GdbLaunch.this);	274	fSession.removeServiceEventListener(GdbLaunch.this);
Lines 307-310 Link Here
307	Platform.getAdapterManager().loadAdapter(this, adapter.getName());	309	Platform.getAdapterManager().loadAdapter(this, adapter.getName());
308	return super.getAdapter(adapter);	310	return super.getAdapter(adapter);
309	}	311	}
		312
		313	/**
		314	* This method can be overridden by subclasses to allow to change the services sequence.
		315	* @since 4.0
		316	*/
		317	public Sequence getServicesSequence(ServiceSequenceOperation type, RequestMonitorWithProgress rm) {
		318	return new GdbServicesSequence(type, getSession(), this, rm);
		319	}
310	}	320	}

Removed Link Here

(-)src/org/eclipse/cdt/dsf/gdb/launching/ShutdownSequence.java (-166 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2010 Wind River Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Wind River Systems - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.cdt.dsf.gdb.launching;
12
13	import org.eclipse.cdt.dsf.concurrent.DsfExecutor;
14	import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
15	import org.eclipse.cdt.dsf.concurrent.Sequence;
16	import org.eclipse.cdt.dsf.debug.service.IBreakpoints;
17	import org.eclipse.cdt.dsf.debug.service.IDisassembly;
18	import org.eclipse.cdt.dsf.debug.service.IExpressions;
19	import org.eclipse.cdt.dsf.debug.service.IMemory;
20	import org.eclipse.cdt.dsf.debug.service.IModules;
21	import org.eclipse.cdt.dsf.debug.service.IProcesses;
22	import org.eclipse.cdt.dsf.debug.service.IRegisters;
23	import org.eclipse.cdt.dsf.debug.service.IRunControl;
24	import org.eclipse.cdt.dsf.debug.service.ISourceLookup;
25	import org.eclipse.cdt.dsf.debug.service.IStack;
26	import org.eclipse.cdt.dsf.debug.service.command.ICommandControl;
27	import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;
28	import org.eclipse.cdt.dsf.gdb.service.IGDBTraceControl;
29	import org.eclipse.cdt.dsf.mi.service.IMIBackend;
30	import org.eclipse.cdt.dsf.mi.service.MIBreakpointsManager;
31	import org.eclipse.cdt.dsf.service.DsfServicesTracker;
32	import org.eclipse.cdt.dsf.service.IDsfService;
33
34	public class ShutdownSequence extends Sequence {
35
36	String fSessionId;
37
38	String fApplicationName;
39
40	String fDebugModelId;
41
42	DsfServicesTracker fTracker;
43
44	public ShutdownSequence(DsfExecutor executor, String sessionId, RequestMonitor requestMonitor) {
45	super(executor, requestMonitor);
46	fSessionId = sessionId;
47	}
48
49	@Override
50	public Step[] getSteps() {
51	return fSteps;
52	}
53
54	private final Step[] fSteps = new Step[] { new Step() {
55	@Override
56	public void execute(RequestMonitor requestMonitor) {
57	assert GdbPlugin.getBundleContext() != null;
58	fTracker = new DsfServicesTracker(GdbPlugin.getBundleContext(), fSessionId);
59	requestMonitor.done();
60	}
61
62	@Override
63	public void rollBack(RequestMonitor requestMonitor) {
64	fTracker.dispose();
65	fTracker = null;
66	requestMonitor.done();
67	}
68	}, new Step() {
69	@Override
70	public void execute(RequestMonitor requestMonitor) {
71	shutdownService(IGDBTraceControl.class, requestMonitor);
72	}
73	}, new Step() {
74	@Override
75	public void execute(RequestMonitor requestMonitor) {
76	shutdownService(IDisassembly.class, requestMonitor);
77	}
78	}, new Step() {
79	@Override
80	public void execute(RequestMonitor requestMonitor) {
81	shutdownService(IRegisters.class, requestMonitor);
82	}
83	}, new Step() {
84	@Override
85	public void execute(RequestMonitor requestMonitor) {
86	shutdownService(MIBreakpointsManager.class, requestMonitor);
87	}
88	}, new Step() {
89	@Override
90	public void execute(RequestMonitor requestMonitor) {
91	shutdownService(IBreakpoints.class, requestMonitor);
92	}
93	}, new Step() {
94	@Override
95	public void execute(RequestMonitor requestMonitor) {
96	shutdownService(ISourceLookup.class, requestMonitor);
97	}
98	}, new Step() {
99	@Override
100	public void execute(RequestMonitor requestMonitor) {
101	shutdownService(IExpressions.class, requestMonitor);
102	}
103	}, new Step() {
104	@Override
105	public void execute(RequestMonitor requestMonitor) {
106	shutdownService(IStack.class, requestMonitor);
107	}
108	}, new Step() {
109	@Override
110	public void execute(RequestMonitor requestMonitor) {
111	shutdownService(IModules.class, requestMonitor);
112	}
113	}, new Step() {
114	@Override
115	public void execute(RequestMonitor requestMonitor) {
116	shutdownService(IMemory.class, requestMonitor);
117	}
118	}, new Step() {
119	@Override
120	public void execute(RequestMonitor requestMonitor) {
121	shutdownService(IRunControl.class, requestMonitor);
122	}
123	}, new Step() {
124	@Override
125	public void execute(RequestMonitor requestMonitor) {
126	shutdownService(IProcesses.class, requestMonitor);
127	}
128	}, new Step() {
129	@Override
130	public void execute(RequestMonitor requestMonitor) {
131	shutdownService(ICommandControl.class, requestMonitor);
132	}
133	}, new Step() {
134	@Override
135	public void execute(RequestMonitor requestMonitor) {
136	shutdownService(IMIBackend.class, requestMonitor);
137	}
138	}, new Step() {
139	@Override
140	public void execute(RequestMonitor requestMonitor) {
141	fTracker.dispose();
142	fTracker = null;
143	requestMonitor.done();
144	}
145	} };
146
147	@SuppressWarnings("unchecked")
148	private void shutdownService(Class clazz, final RequestMonitor requestMonitor) {
149	IDsfService service = (IDsfService)fTracker.getService(clazz);
150	if (service != null) {
151	service.shutdown(new RequestMonitor(getExecutor(), requestMonitor) {
152	@Override
153	protected void handleCompleted() {
154	if (!isSuccess()) {
155	GdbPlugin.getDefault().getLog().log(getStatus());
156	}
157	requestMonitor.done();
158	}
159	});
160	} else {
161	// It is possible that a particular service was not instantiated at all
162	// depending on our backend
163	requestMonitor.done();
164	}
165	}
166	}

Lines 20-31 Link Here

(-)src/org/eclipse/cdt/dsf/gdb/launching/GdbLaunchDelegate.java (-2 / +5 lines)
20	import org.eclipse.cdt.core.model.ICProject;	20	import org.eclipse.cdt.core.model.ICProject;
21	import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;	21	import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
22	import org.eclipse.cdt.dsf.concurrent.DsfExecutor;	22	import org.eclipse.cdt.dsf.concurrent.DsfExecutor;
		23	import org.eclipse.cdt.dsf.concurrent.ImmediateExecutor;
23	import org.eclipse.cdt.dsf.concurrent.Query;	24	import org.eclipse.cdt.dsf.concurrent.Query;
		25	import org.eclipse.cdt.dsf.concurrent.RequestMonitorWithProgress;
24	import org.eclipse.cdt.dsf.concurrent.Sequence;	26	import org.eclipse.cdt.dsf.concurrent.Sequence;
25	import org.eclipse.cdt.dsf.concurrent.ThreadSafe;	27	import org.eclipse.cdt.dsf.concurrent.ThreadSafe;
26	import org.eclipse.cdt.dsf.debug.service.IDsfDebugServicesFactory;	28	import org.eclipse.cdt.dsf.debug.service.IDsfDebugServicesFactory;
27	import org.eclipse.cdt.dsf.debug.sourcelookup.DsfSourceLookupDirector;	29	import org.eclipse.cdt.dsf.debug.sourcelookup.DsfSourceLookupDirector;
28	import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;	30	import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;
		31	import org.eclipse.cdt.dsf.gdb.launching.GdbServicesSequence.ServiceSequenceOperation;
29	import org.eclipse.cdt.dsf.gdb.service.GdbDebugServicesFactory;	32	import org.eclipse.cdt.dsf.gdb.service.GdbDebugServicesFactory;
30	import org.eclipse.cdt.dsf.gdb.service.GdbDebugServicesFactoryNS;	33	import org.eclipse.cdt.dsf.gdb.service.GdbDebugServicesFactoryNS;
31	import org.eclipse.cdt.dsf.gdb.service.SessionType;	34	import org.eclipse.cdt.dsf.gdb.service.SessionType;
Lines 140-147 Link Here
140		143
141	// Create and invoke the launch sequence to create the debug control and services	144	// Create and invoke the launch sequence to create the debug control and services
142	IProgressMonitor subMon1 = new SubProgressMonitor(monitor, 4, SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK);	145	IProgressMonitor subMon1 = new SubProgressMonitor(monitor, 4, SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK);
143	final ServicesLaunchSequence servicesLaunchSequence =	146	final Sequence servicesLaunchSequence =
144	new ServicesLaunchSequence(launch.getSession(), launch, subMon1);	147	launch.getServicesSequence(ServiceSequenceOperation.INITIALIZE, new RequestMonitorWithProgress(ImmediateExecutor.getInstance(), subMon1));
145		148
146	launch.getSession().getExecutor().execute(servicesLaunchSequence);	149	launch.getSession().getExecutor().execute(servicesLaunchSequence);
147	try {	150	try {