Java DebugEvent类代码示例

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
/**
 * Handles the given {@link ResumingReply}.
 * 
 * @param resumingReply
 *            the {@link ResumingReply}
 */
private void handleResumingReply(ResumingReply resumingReply) {
	final Thread eThread = DebugTargetUtils.getThread(getHost(), resumingReply.getThreadName());
	if (resumingReply instanceof StepIntoResumingReply) {
		// EMF model change
		factory.getModelUpdater().stepIntoReply(eThread);
		// Eclipse change
		factory.getThread(eThread).fireResumeEvent(DebugEvent.STEP_INTO);
	} else if (resumingReply instanceof StepOverResumingReply) {
		// EMF model change
		factory.getModelUpdater().stepOverReply(eThread);
		// Eclipse change
		factory.getThread(eThread).fireResumeEvent(DebugEvent.STEP_OVER);
	} else if (resumingReply instanceof StepReturnResumingReply) {
		// EMF model change
		factory.getModelUpdater().stepReturnReply(eThread);
		// Eclipse change
		factory.getThread(eThread).fireResumeEvent(DebugEvent.STEP_RETURN);
	} else {
		// EMF model change
		factory.getModelUpdater().resumedReply(eThread);
		// Eclipse change
		factory.getThread(eThread).fireResumeEvent(DebugEvent.CLIENT_REQUEST);
	}
	fireChangeEvent(DebugEvent.STATE);
}
 

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
/**
 * Handles the given {@link SuspendedReply}.
 * 
 * @param suspendReply
 *            the {@link SuspendedReply}
 */
private void handleSuspendReply(SuspendedReply suspendReply) {
	final Thread eThread = DebugTargetUtils.getThread(getHost(), suspendReply.getThreadName());
	final DSLThreadAdapter thread = factory.getThread(eThread);

	// EMF model change
	factory.getModelUpdater().suspendedReply(eThread);
	// Eclipse change
	if (suspendReply instanceof SteppedReply) {
		thread.fireSuspendEvent(DebugEvent.STEP_END);
	} else if (suspendReply instanceof BreakpointReply) {
		thread.fireSuspendEvent(DebugEvent.BREAKPOINT);
	} else {
		thread.fireSuspendEvent(DebugEvent.CLIENT_REQUEST);
	}
	fireChangeEvent(DebugEvent.STATE);
	// notify our suspend listeners

}
 

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
@Override
public void serverChanged(ServerEvent event) {
  Preconditions.checkState(server == event.getServer());
  switch (event.getState()) {
    case IServer.STATE_STARTED:
      openBrowserPage(server);
      fireChangeEvent(DebugEvent.STATE);
      return;

    case IServer.STATE_STOPPED:
      server.removeServerListener(serverEventsListener);
      fireTerminateEvent();
      try {
        logger.fine("Server stopped; terminating launch"); //$NON-NLS-1$
        launch.terminate();
      } catch (DebugException ex) {
        logger.log(Level.WARNING, "Unable to terminate launch", ex); //$NON-NLS-1$
      }
      return;

    default:
      fireChangeEvent(DebugEvent.STATE);
      return;
  }
}
 

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
protected void handleDebugEvent(DebugEvent debugEvent) {
	updateActions();
	switch (debugEvent.getKind()) {
		case DebugEvent.TERMINATE :
			setViewerInput(null);
			break;
		case DebugEvent.SUSPEND :
			break;
		case DebugEvent.RESUME :
			break;
	}
	Display.getDefault().asyncExec(() -> {
		if (debugEvent.getSource() != null) {
			sessionDropdown.refresh();
			targets.removeIf(dt -> dt.isTerminated());
		}
	});
}
 

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
public void onBreakpointHit(ProductMessage productMessage) {
  System.out.println("MontoDebugTarget.onBreakpointHit()");
  HitBreakpoint hitBreakpoint = GsonMonto.fromJson(productMessage, HitBreakpoint.class);

  if (productMessage.getSource().equals(sessionSource)) {
    isSuspended = true;

    MontoThread hitThread = convertMontoToEclipseThread(this, hitBreakpoint.getHitThread());
    threads.clear();
    threads.add(hitThread);
    for (Thread montoThread : hitBreakpoint.getOtherThreads()) {
      threads.add(convertMontoToEclipseThread(this, montoThread));
    }
    threads.forEach(thread -> thread.fireSuspendEvent(DebugEvent.BREAKPOINT));
  }
}
 

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
void onProcessTerminatedProduct(ProductMessage productMessage) {
  if (productMessage.getSource().equals(sessionSource)) {
    ProcessTerminated processTerminated =
        GsonMonto.fromJson(productMessage, ProcessTerminated.class);

    terminated = true;
    exitCode = processTerminated.getExitCode();
    System.out.println("Process " + sessionId + " terminated");
    DebugPlugin.getDefault()
        .fireDebugEventSet(new DebugEvent[] {new DebugEvent(this, DebugEvent.TERMINATE)});

    // deregister product listeners

    // Deregistration needs to happen is separate thread, because removing listeners in this
    // callback method, which is called from the SinkDemultiplexer thread, causes a
    // ConcurrentModification exception in the SinkDemultiplexer thread, because the listener
    // map/list is SinkDemultiplexer is modified, before all listeners are called
    CompletableFuture.runAsync(() -> {
      Activator.getDefault().getDemultiplexer().removeProductListener(Products.PROCESS_TERMINATED,
          this);
      Activator.getDefault().getDemultiplexer().removeProductListener(Products.STREAM_OUTPUT,
          this);
    });
  }
}
 

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
/**
 * When a Server runtime server is started and terminated, and the project has a GWT Facet, start and stop the GWT
 * Super Dev Mode Code Server with runtime server.
 */
@Override
public void start(BundleContext context) throws Exception {
  super.start(context);

  // Observe launch events that are from the WTP server
  serverProcessListener = new IDebugEventSetListener() {
    @Override
    public void handleDebugEvents(DebugEvent[] events) {
      if (events != null) {
        onDebugEvents(events);
      }
    }
  };
  DebugPlugin.getDefault().addDebugEventListener(serverProcessListener);
}
 

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
private void onAfterCodeServerStarted(DebugEvent event) {
  if (!(event.getSource() instanceof IProcess)) {
    return;
  }

  IProcess runtimeProcess = (IProcess) 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
  consoleStreamListenerCodeServer = new IStreamListener() {
    @Override
    public void streamAppended(String text, IStreamMonitor monitor) {
      displayCodeServerUrlInDevMode(launch, text);
    }
  };

  // Listen to Console output
  streamMonitorCodeServer = process.getStreamsProxy().getOutputStreamMonitor();
  streamMonitorCodeServer.addListener(consoleStreamListenerCodeServer);
}
 

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
@Override
public void interpreterSuspended(InterpreterState state, List<EventReason> eventReasons) {
	this.suspendedState = state;
	this.isSuspended = true;
	synchronized (this.debugElements) {
		for (DebugElement element : this.debugElements) {
			if (eventReasons.contains(EventReason.BreakPoint) || eventReasons.contains(EventReason.WatchPoint)) {
				element.fireSuspendEvent(DebugEvent.BREAKPOINT);
			}
			if (eventReasons.contains(EventReason.ClientRequest)) {
				element.fireSuspendEvent(DebugEvent.CLIENT_REQUEST);
			}
			if (eventReasons.contains(EventReason.StepEnd)) {
				element.fireSuspendEvent(DebugEvent.STEP_END);
			}
		}
	}
}
 

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
@Override
public void interpreterFinished(InterpreterState state, List<EventReason> reasons) {
	this.isStopped = true;
	this.isSuspended = false;
	IDebugTarget target = null;
	if (DebugPlugin.getDefault() != null) {
		synchronized (this.debugElements) {
			for (DebugElement element : this.debugElements) {
				element.fireTerminateEvent();
				target = element.getDebugTarget();
			}
		}
		DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[]{new DebugEvent(BfProcess.this, DebugEvent.TERMINATE)});
		if (target != null && target instanceof BfDebugTarget) {
			((BfDebugTarget) target).fireTerminateEvent();
		}
	}
}
 

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
public void handleDebugEvents(DebugEvent[] events) {
  for (DebugEvent event : events) {
    switch (event.getKind()) {
      case DebugEvent.TERMINATE:
        if (event.getSource().equals(getDebugTarget())) {
          DebugPlugin.getDefault().getExpressionManager().removeExpression(this);
        }
        break;
      case DebugEvent.SUSPEND:
        if (event.getDetail() != DebugEvent.EVALUATION_IMPLICIT &&
            event.getSource() instanceof IDebugElement) {
          IDebugElement source = (IDebugElement) event.getSource();
          if (source.getDebugTarget().equals(getDebugTarget())) {
            DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[] {
                new DebugEvent(this, DebugEvent.CHANGE, DebugEvent.CONTENT) });
          }
        }
        break;
    }
  }
}
 

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
@Test
public void multipleSessionsAreTracked() {
	FakePlugin fp = new FakePlugin();
	RuntimeSessionTracker rst = new RuntimeSessionTracker(null, fp);
	assertThat("The session should be alive", fp.shutdownWasCalled, is(0));
	rst.handleDebugEvents(new DebugEvent[] {new DebugEvent(new FakeProcess(), DebugEvent.CREATE)});
	rst.handleDebugEvents(new DebugEvent[] {new DebugEvent(new FakeProcess(), DebugEvent.CREATE)});
	assertThat("The session should be alive", fp.shutdownWasCalled, is(0));
	rst.handleDebugEvents(new DebugEvent[] {new DebugEvent(new FakeProcess(), DebugEvent.TERMINATE)});
	assertThat("The session should be alive", fp.shutdownWasCalled, is(0));
	rst.handleDebugEvents(new DebugEvent[] {new DebugEvent(new FakeProcess(), DebugEvent.CREATE)});
	rst.handleDebugEvents(new DebugEvent[] {new DebugEvent(new FakeProcess(), DebugEvent.TERMINATE)});
	assertThat("The session should be alive", fp.shutdownWasCalled, is(0));
	rst.handleDebugEvents(new DebugEvent[] {new DebugEvent(new FakeProcess(), DebugEvent.TERMINATE)});
	assertThat("The session should be over", fp.shutdownWasCalled, is(1));
}
 

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
@Override
public void handleDebugEvents(DebugEvent[] events) {
	for (DebugEvent debugEvent : events) {
		if (debugEvent.getSource() instanceof IProcess &&
				((IProcess)debugEvent.getSource()).getLaunch() == trackedLaunch) {
			if (debugEvent.getKind() == DebugEvent.CREATE) {
				liveProcessCount++;
				assert liveProcessCount > 0;
			}
			else if (debugEvent.getKind() == DebugEvent.TERMINATE) {
				liveProcessCount--;
				assert liveProcessCount >= 0;
				if (liveProcessCount == 0) {
					dispose();
				}
			}
		}
	}
}
 

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
@Override
public void handleDebugEvents(final DebugEvent[] events) {
    for (final DebugEvent event : events) {
        if (event.getSource().equals(process)) {
            if (event.getKind() == DebugEvent.TERMINATE) {
                if (shellConnection != null) {
                    try {
                        shellConnection.disconnect();
                    } catch (final IOException e) {
                        KarafUIPluginActivator.getLogger().error("Unable to disconnect from SSH server", e);
                    }
                }
                DebugPlugin.getDefault().removeDebugEventListener(this);

                resetName();
            }
        }
    }
}
 

import org.eclipse.debug.core.DebugEvent; //导入依赖的package包/类
@Override
public void handleDebugEvents(DebugEvent[] events) {
	for (DebugEvent event : events) {
		switch (event.getKind()) {
		case DebugEvent.CREATE:
			if (event.getSource() instanceof IDebugTarget) {
				WatchDogEventType.START_DEBUG.process(this);
			}
			break;

		case DebugEvent.TERMINATE:
			if (event.getSource() instanceof IDebugTarget) {
				WatchDogEventType.END_DEBUG.process(this);
			}
			break;

		default:
			break;
		}
	}
}