public void handleDebugEvents(DebugEvent[] events) {
if (events != null && project != null) {
int size = events.length;
for (int i = 0; i < size; i++) {
for (IProcess process : processes) {
if (process != null
&& process.equals(events[i].getSource())
&& events[i].getKind() == DebugEvent.TERMINATE) {
DebugPlugin.getDefault().removeDebugEventListener(this);
terminateForked();
Job job =
new Job("refresh project") {
@Override
protected IStatus run(IProgressMonitor monitor) {
try {
project.refreshLocal(IResource.DEPTH_INFINITE, monitor);
} catch (CoreException e) {
}
GrailsCoreActivator.getDefault().notifyCommandFinish(project);
return Status.OK_STATUS;
}
};
job.setSystem(true);
job.setRule(ResourcesPlugin.getWorkspace().getRuleFactory().buildRule());
job.setPriority(Job.INTERACTIVE);
job.schedule();
}
}
}
}
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.debug.internal.ui.contexts.provisional.IDebugContextListener
* #contextEvent
* (org.eclipse.debug.internal.ui.contexts.provisional.DebugContextEvent)
*/
public void debugContextChanged(final DebugContextEvent event) {
if ((event.getFlags() & DebugContextEvent.ACTIVATED) > 0) {
IProcess process = getProcess();
if (fView != null && process != null && process.equals(DebugUITools.getCurrentProcess())) {
fView.display(fConsole);
}
}
}
@Override
public boolean finalLaunchCheck(
ILaunchConfiguration configuration, String mode, IProgressMonitor monitor)
throws CoreException {
// Check for existing launches of same resource
BndPreferences prefs = new BndPreferences();
if (prefs.getWarnExistingLaunches()) {
IResource launchResource = LaunchUtils.getTargetResource(configuration);
if (launchResource == null)
throw new CoreException(
new Status(
IStatus.ERROR,
Plugin.PLUGIN_ID,
0,
"Bnd launch target was not specified or does not exist.",
null));
int processCount = 0;
for (ILaunch l : DebugPlugin.getDefault().getLaunchManager().getLaunches()) {
// ... is it the same launch resource?
ILaunchConfiguration launchConfig = l.getLaunchConfiguration();
if (launchConfig == null) {
continue;
}
if (launchResource.equals(LaunchUtils.getTargetResource(launchConfig))) {
// Iterate existing processes
for (IProcess process : l.getProcesses()) {
if (!process.isTerminated()) processCount++;
}
}
}
// Warn if existing processes running
if (processCount > 0) {
Status status =
new Status(
IStatus.WARNING,
Plugin.PLUGIN_ID,
0,
"One or more OSGi Frameworks have already been launched for this configuration. Additional framework instances may interfere with each other due to the shared storage directory.",
null);
IStatusHandler prompter = DebugPlugin.getDefault().getStatusHandler(status);
if (prompter != null) {
boolean okay = (Boolean) prompter.handleStatus(status, launchResource);
if (!okay) return okay;
}
}
}
IStatus launchStatus = getLauncherStatus();
IStatusHandler prompter = DebugPlugin.getDefault().getStatusHandler(launchStatus);
if (prompter != null) return (Boolean) prompter.handleStatus(launchStatus, model);
return true;
}
public boolean isPVSRunning() {
ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
IProcess[] processes = manager.getProcesses();
for (IProcess p : processes) {
if (Activator.name.equals(p.getLabel())) {
return !p.isTerminated();
}
}
return false;
// TODO: this should later be replaced by:
// return mode != PVSMode.OFF;
}
private void tryConnect() throws RpcException {
synchronized (connectLock) {
switch (state) {
case DISCONNECTED:
reported = false;
if (connectRetry()) {
state = State.CONNECTED;
} else if (connectOnce) {
state = State.DOWN;
} else {
state = State.DISCONNECTED;
}
break;
case CONNECTED:
break;
case DOWN:
try {
if (process != null) {
process.terminate();
}
} catch (final DebugException e) {
ErlLogger.info(e);
}
// TODO restart it??
// process =
if (!stopped) {
final String msg = reportRuntimeDown(data.getNodeName());
throw new RpcException(msg);
}
}
}
}
/* (non-Javadoc)
* @see java.lang.Thread#run()
*/
public IStatus run(IProgressMonitor mon) {
try {
// There is no join on a process available, so we will have to
// busy wait. Give it 10 seconds in 1/10 second intervals.
for (int i = 0; !process.isTerminated() && i < 100; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
}
if (!process.isTerminated()) {
process.terminate();
}
} catch (DebugException e) {
}
return Status.OK_STATUS;
}
public void stopPVS() {
if (iprocess != null) {
if (iprocess.canTerminate()) {
try {
iprocess.terminate();
iprocess = null;
process = null;
for (PVSStateChangeListener l : stateListeners) {
l.sourceChanged(PVSConstants.PVSRUNNING, PVSConstants.FALSE);
}
DebugPlugin.getDefault().removeDebugEventListener(instance);
} catch (DebugException e) {
e.printStackTrace();
}
}
}
mode = PVSMode.OFF;
}
@Override
public void selectionChanged(final IAction action, final ISelection selection) {
fLaunch = null;
if (selection instanceof IStructuredSelection) {
final IStructuredSelection ss = (IStructuredSelection) selection;
for (final Object o : ss.toArray()) {
if (o instanceof ErlangDebugElement) {
final ErlangDebugElement d = (ErlangDebugElement) o;
fLaunch = d.getLaunch();
} else if (o instanceof ILaunch) {
fLaunch = (ILaunch) o;
} else if (o instanceof IProcess) {
final IProcess p = (IProcess) o;
fLaunch = p.getLaunch();
}
}
}
}
private void processSdmCodeServerLauncher(DebugEvent event) {
RuntimeProcess runtimeProcess = (RuntimeProcess) event.getSource();
final ILaunch launch = runtimeProcess.getLaunch();
IProcess[] processes = launch.getProcesses();
final IProcess process = processes[0];
// Look for the links in the sdm console output
consoleStreamListener =
new IStreamListener() {
@Override
public void streamAppended(String text, IStreamMonitor monitor) {
displayCodeServerUrlInDevMode(launch, text);
}
};
// Listen to Console output
streamMonitor = process.getStreamsProxy().getOutputStreamMonitor();
streamMonitor.addListener(consoleStreamListener);
}
private void registerProcess(
ILaunch launch,
SDBGLaunchConfigWrapper launchConfig,
IProcess process,
String processDescription) {
launch.setAttribute(DebugPlugin.ATTR_CONSOLE_ENCODING, "UTF-8");
launch.addProcess(process);
if (processDescription != null) {
process.setAttribute(IProcess.ATTR_CMDLINE, processDescription);
}
}
private void terminateForked() {
if (killPorts != null) {
for (int killPort : killPorts) {
try {
URI killUrl = new URI("http://localhost:" + killPort);
HttpUtil.ping(killUrl);
} catch (Throwable e) {
}
}
}
if (processes != null && processes.length > 1) {
// Make sure all processes are terminated
for (IProcess process : processes) {
try {
if (process.canTerminate() && !process.isTerminated()) {
process.terminate();
}
} catch (Throwable e) {
GrailsCoreActivator.log(e);
}
}
processes = null;
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.part.IShowInSource#getShowInContext()
*/
public ShowInContext getShowInContext() {
IProcess process = getProcess();
if (process == null) {
return null;
}
IDebugTarget target = (IDebugTarget) process.getAdapter(IDebugTarget.class);
ISelection selection = null;
if (target == null) {
selection =
new TreeSelection(
new TreePath(
new Object[] {
DebugPlugin.getDefault().getLaunchManager(), process.getLaunch(), process
}));
} else {
selection =
new TreeSelection(
new TreePath(
new Object[] {
DebugPlugin.getDefault().getLaunchManager(), target.getLaunch(), target
}));
}
return new ShowInContext(null, selection);
}
@Override
protected void init() {
super.init();
if (process.isTerminated()) {
if (shellConnection != null) {
try {
shellConnection.disconnect();
} catch (final IOException e) {
KarafUIPluginActivator.getLogger().error("Unable to disconnect from SSH server", e);
}
}
} else {
DebugPlugin.getDefault().addDebugEventListener(this);
}
}
/**
* Computes and returns the current name of this console.
*
* @return a name for this console
*/
protected String computeName() {
String label = null;
final IProcess process = getProcess();
final ILaunchConfiguration config = process.getLaunch().getLaunchConfiguration();
label = process.getAttribute(IProcess.ATTR_PROCESS_LABEL);
if (label == null) {
if (config == null) {
label = process.getLabel();
} else {
// check if PRIVATE config
if (DebugUITools.isPrivate(config)) {
label = process.getLabel();
} else {
String type = null;
try {
type = config.getType().getName();
} catch (final CoreException e) {
}
final StringBuffer buffer = new StringBuffer();
buffer.append("Remote shell connection to: ");
buffer.append(config.getName());
if (type != null) {
buffer.append(" ["); // $NON-NLS-1$
buffer.append(type);
buffer.append("] "); // $NON-NLS-1$
}
buffer.append(process.getLabel());
label = buffer.toString();
}
}
}
if (process.isTerminated()) {
return MessageFormat.format("<disconnected> {0}", (Object[]) new String[] {label});
}
return label;
}
public void execute(IProgressMonitor monitor) throws Exception {
/*
* use the ExecutePomAction directly.
*/
// ExecutePomAction exePomAction = new ExecutePomAction();
// exePomAction.setInitializationData(null, null, MavenConstants.GOAL_COMPILE);
// exePomAction.launch(new StructuredSelection(launcherPomFile), ILaunchManager.RUN_MODE);
/*
* use launch way
*/
// try{
ILaunchConfiguration launchConfiguration = createLaunchConfiguration();
if (launchConfiguration == null) {
throw new Exception("Can't create maven command launcher.");
}
// if (launchConfiguration instanceof ILaunchConfigurationWorkingCopy) {
// ILaunchConfigurationWorkingCopy copiedConfig = (ILaunchConfigurationWorkingCopy)
// launchConfiguration;
// }
TalendLauncherWaiter talendWaiter = new TalendLauncherWaiter(launchConfiguration);
final ILaunch launch = buildAndLaunch(launchConfiguration, launcherMode, monitor);
talendWaiter.waitFinish(launch);
StringBuffer errors = new StringBuffer();
for (IProcess process : launch.getProcesses()) {
String log = process.getStreamsProxy().getOutputStreamMonitor().getContents();
if (!isCaptureOutputInConsoleView()) {
// specially for commandline. if studio, when debug model, will log it in console view, so
// no need this.
TalendDebugHandler.debug(
"\n------------------ Talend Maven Launcher log START -----------------------\n");
TalendDebugHandler.debug(log);
TalendDebugHandler.debug(
"\n------------------ Talend Maven Launcher log END -----------------------\n");
}
for (String line : log.split("\n")) { // $NON-NLS-1$
if (line.startsWith("[ERROR]")) { // $NON-NLS-1$
errors.append(line + "\n"); // $NON-NLS-1$
}
}
}
if (errors.length() > 0) {
if (getGoals() != null
&& getGoals()
.matches(
"(.*)\\b"
+ TalendMavenConstants.GOAL_TEST
+ "\\b(.*)")) { //$NON-NLS-1$//$NON-NLS-2$
ExceptionHandler.process(new Exception(errors.toString()));
} else {
throw new Exception(errors.toString());
}
}
// }finally{
// if (launch != null) {
// if remove, after execute launch, will remove the console also. so shouldn't remove it.
// DebugPlugin.getDefault().getLaunchManager().removeLaunch(launch);
// }
// }
}
/** When a console page is initialized, */
public void init(IPageBookViewPage page, final IConsole console) {
if (!(console instanceof ProcessConsole)) {
return;
}
ProcessConsole processConsole = (ProcessConsole) console;
IProcess process = processConsole.getProcess();
if (process == null) {
return;
}
if (!PyCodeCompletionPreferencesPage.useCodeCompletion()
|| !PyCodeCompletionPreferencesPage.useCodeCompletionOnDebug()) {
return;
}
String attribute = process.getAttribute(Constants.PYDEV_DEBUG_IPROCESS_ATTR);
if (!Constants.PYDEV_DEBUG_IPROCESS_ATTR_TRUE.equals(attribute)) {
// Only provide code-completion for pydev debug processes.
return;
}
Control control = page.getControl();
if (page instanceof IOConsolePage) {
// Note that completions on "all letters and '_'" are already activated just by installing
// the content assist, but the completions on the default keybinding is not, so, we have to
// call it ourselves here.
control.addKeyListener(
new KeyListener() {
public void keyPressed(KeyEvent e) {
if (KeyBindingHelper.matchesContentAssistKeybinding(e)) {
contentAssist.showPossibleCompletions();
}
}
public void keyReleased(KeyEvent e) {}
});
IOConsolePage consolePage = (IOConsolePage) page;
TextConsoleViewer viewer = consolePage.getViewer();
contentAssist =
new PyContentAssistant() {
public String showPossibleCompletions() {
// Only show completions if we're in a suspended console.
if (getCurrentSuspendedPyStackFrame(console) == null) {
return null;
}
return super.showPossibleCompletions();
};
};
contentAssist.setInformationControlCreator(
PyContentAssistant.createInformationControlCreator(viewer));
ILaunch launch = process.getLaunch();
IDebugTarget debugTarget = launch.getDebugTarget();
IInterpreterInfo projectInterpreter = null;
if (debugTarget instanceof PyDebugTarget) {
PyDebugTarget pyDebugTarget = (PyDebugTarget) debugTarget;
PythonNature nature = PythonNature.getPythonNature(pyDebugTarget.project);
if (nature != null) {
try {
projectInterpreter = nature.getProjectInterpreter();
} catch (Throwable e1) {
Log.log(e1);
}
}
}
contentAssist.install(new ScriptConsoleViewerWrapper(viewer, projectInterpreter));
PydevConsoleInterpreter interpreter = new PydevConsoleInterpreter();
interpreter.setConsoleCommunication(new GetCompletionsInDebug());
IContentAssistProcessor processor =
new PydevConsoleCompletionProcessor(interpreter, contentAssist);
contentAssist.setContentAssistProcessor(processor, IOConsolePartition.INPUT_PARTITION_TYPE);
contentAssist.setContentAssistProcessor(processor, IOConsolePartition.OUTPUT_PARTITION_TYPE);
contentAssist.enableAutoActivation(true);
contentAssist.enableAutoInsert(false);
contentAssist.setAutoActivationDelay(PyCodeCompletionPreferencesPage.getAutocompleteDelay());
}
}
/**
* the command has been executed, so extract extract the needed information from the application
* context.
*/
public Object execute(ExecutionEvent event) throws ExecutionException {
log.fine("Message to start PVS was received");
window = HandlerUtil.getActiveWorkbenchWindowChecked(event);
if (PVSExecutionManager.INST().isPVSRunning()) {
MessageDialog.openInformation(
window.getShell(), "PVS Running", "An instance of PVS is already running.");
} else {
try {
final PVSConsole console = PVSConsole.getConsole();
console.activate();
console.clearConsole();
final IOConsoleOutputStream outStream = console.newOutputStream();
Map<String, String> attributes = new HashMap<String, String>();
attributes.put(IProcess.ATTR_CMDLINE, PVSExecutionManager.INST().getPVSStartingCommand());
ILaunch launch = new Launch(null, ILaunchManager.RUN_MODE, null);
IProcess process =
DebugPlugin.newProcess(
launch, PVSExecutionManager.INST().startPVS(), Activator.name, attributes);
PVSExecutionManager.INST().setIProcess(process);
DebugPlugin.getDefault().getLaunchManager().addLaunch(launch);
DebugPlugin.getDefault().addDebugEventListener(PVSExecutionManager.INST());
PVSJsonWrapper.init();
PVSExecutionManager.INST().removeRespondListeners();
PVSExecutionManager.INST()
.addListener(
new PVSRespondListener() {
@Override
public void onMessageReceived(String message) {
log.log(Level.INFO, "Message received: {0}", message);
try {
outStream.write(message);
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void onMessageReceived(JSONObject message) {
log.log(Level.INFO, "JSON received: {0}", message);
PVSJsonWrapper.INST().addToJSONQueue(message);
}
@Override
public void onPromptReceived(List<String> previousLines, String prompt) {
log.log(Level.INFO, "Prompt received: {0}", prompt);
try {
outStream.write(prompt);
} catch (IOException e) {
e.printStackTrace();
}
PVSPromptProcessor.processPrompt(previousLines, prompt);
}
});
IStreamsProxy streamProxy = process.getStreamsProxy();
IStreamMonitor outMonitor = streamProxy.getOutputStreamMonitor();
outMonitor.addListener(new PVSStreamListener(EclipsePluginUtil.getLispType()));
IOConsoleKeyboardReader.init(console);
IOConsoleKeyboardReader.INST()
.addListener(
new IOConsoleKeyboardReader.IOConsoleKeyboardReaderListener() {
public void onTextReceived(String text) {
PVSExecutionManager.INST().writeToPVS(text);
}
});
IOConsoleKeyboardReader.INST().start();
Thread.sleep(500);
restorePVSContext();
} catch (IOException e) {
log.severe("Failed to start PVS");
MessageDialog.openInformation(window.getShell(), "Error", "Failed to start PVS");
} catch (InterruptedException e) {
log.severe("Failed to restore PVS context");
MessageDialog.openInformation(
window.getShell(), "Error", "Failed to restore the PVS context");
} catch (PVSException e) {
log.severe("Failed to restore PVS context");
MessageDialog.openInformation(
window.getShell(), "Error", "Failed to restore the PVS context");
}
}
return null;
}
public KarafRemoteConsole(
final IProcess process,
final KarafSshConnectionUrl connectionUrl,
final KarafSshShellConnection.Credentials credentials,
final IConsoleColorProvider colorProvider,
final String name,
final String encoding) {
super(
name,
KARAF_REMOTE_CONSOLE_TYPE,
KarafUIPluginActivator.getDefault()
.getImageRegistry()
.getDescriptor(KarafUIPluginActivator.LOGO_16X16_IMG),
encoding,
true);
this.process = process;
this.inputStream = getInputStream();
this.colorProvider = colorProvider;
final Color color = this.colorProvider.getColor(IDebugUIConstants.ID_STANDARD_INPUT_STREAM);
this.inputStream.setColor(color);
final InputStream noAvailableInputStream =
new FilterInputStream(inputStream) {
@Override
public int available() throws IOException {
return 0;
}
};
setName(computeName());
final IOConsoleOutputStream outputStream = newOutputStream();
boolean remoteShellEnabled = false;
try {
final ILaunchConfiguration configuration = process.getLaunch().getLaunchConfiguration();
remoteShellEnabled =
configuration.getAttribute(
KarafLaunchConfigurationConstants.KARAF_LAUNCH_START_REMOTE_CONSOLE, false);
} catch (final CoreException e) {
return;
}
if (remoteShellEnabled) {
shellConnection =
new KarafSshShellConnection(
connectionUrl, credentials, noAvailableInputStream, outputStream, outputStream);
final KarafRemoteShellConnectJob job = new KarafRemoteShellConnectJob(name, shellConnection);
job.addJobChangeListener(
new JobChangeAdapter() {
@Override
public void done(final IJobChangeEvent event) {
if (!event.getResult().isOK()) {
final Throwable t = event.getResult().getException();
writeTo(
outputStream,
"Unable to connect to SSH server: "
+ (t != null ? t.getLocalizedMessage() : "Unknown error"));
}
}
});
DebugPlugin.getDefault()
.addDebugEventListener(
new IDebugEventSetListener() {
@Override
public void handleDebugEvents(final DebugEvent[] events) {
for (final DebugEvent event : events) {
if (process != null
&& process.equals(event.getSource())
&& event.getKind() == DebugEvent.TERMINATE) {
job.cancel();
}
}
}
});
job.schedule(15 * 1000);
} else {
writeTo(
outputStream,
"The Karaf remote shell is disabled. Enable it in the launch configuration dialog.");
}
}