Java ProcessHandler.isProcessTerminated方法代码示例

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
public static void update(@NotNull Presentation presentation,
                          @NotNull Presentation templatePresentation,
                          @Nullable ProcessHandler processHandler) {
  boolean enable = false;
  Icon icon = templatePresentation.getIcon();
  String description = templatePresentation.getDescription();
  if (processHandler != null && !processHandler.isProcessTerminated()) {
    enable = true;
    if (processHandler.isProcessTerminating() && processHandler instanceof KillableProcess) {
      KillableProcess killableProcess = (KillableProcess) processHandler;
      if (killableProcess.canKillProcess()) {
        // 'force quite' action presentation
        icon = AllIcons.Debugger.KillProcess;
        description = "Kill process";
      }
    }
  }
  presentation.setEnabled(enable);
  presentation.setIcon(icon);
  presentation.setDescription(description);
}
 

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
@Override
public void actionPerformed(AnActionEvent e) {
  RunContentDescriptor descriptor = StopAction.getRecentlyStartedContentDescriptor(e.getDataContext());
  ProcessHandler activeProcessHandler = descriptor != null ? descriptor.getProcessHandler() : null;
  if (activeProcessHandler == null || activeProcessHandler.isProcessTerminated()) return;

  try {
    OutputStream input = activeProcessHandler.getProcessInput();
    if (input != null) {
      ConsoleView console = e.getData(LangDataKeys.CONSOLE_VIEW);
      if (console != null) {
        console.print("^D\n", ConsoleViewContentType.SYSTEM_OUTPUT);
      }
      input.close();
    }
  }
  catch (IOException ignored) {
  }
}
 

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
private static void stop(@Nullable RunContentDescriptor descriptor) {
  ProcessHandler processHandler = descriptor != null ? descriptor.getProcessHandler() : null;
  if (processHandler == null) {
    return;
  }

  if (processHandler instanceof KillableProcess && processHandler.isProcessTerminating()) {
    ((KillableProcess)processHandler).killProcess();
    return;
  }

  if (!processHandler.isProcessTerminated()) {
    if (processHandler.detachIsDefault()) {
      processHandler.detachProcess();
    }
    else {
      processHandler.destroyProcess();
    }
  }
}
 

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
@Override
protected void disposeDebugProcess() throws InterruptedException {
  if (myDebugProcess != null) {
    ProcessHandler processHandler = myDebugProcess.getProcessHandler();

    myDebugProcess.stop();

    waitFor(processHandler);

    if (!processHandler.isProcessTerminated()) {
      killDebugProcess();
      if (!waitFor(processHandler)) {
        new Throwable("Cannot stop debugger process").printStackTrace();
      }
    }
  }
}
 

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
private static boolean hasRunningProcess(Project project) {
  for (ProcessHandler handler : ExecutionManager.getInstance(project).getRunningProcesses()) {
    if (!handler.isProcessTerminated() && !ALLOW_AUTOMAKE.get(handler, Boolean.FALSE)) { // active process
      return true;
    }
  }
  return false;
}
 

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
public static void restartIfActive(@NotNull RunContentDescriptor descriptor) {
  ProcessHandler processHandler = descriptor.getProcessHandler();
  if (processHandler != null
      && processHandler.isStartNotified()
      && !processHandler.isProcessTerminating()
      && !processHandler.isProcessTerminated()) {
    restart(descriptor);
  }
}
 

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
private static void restartAutoTest(@NotNull RunContentDescriptor descriptor,
                                    int modificationStamp,
                                    @NotNull DelayedDocumentWatcher documentWatcher) {
  ProcessHandler processHandler = descriptor.getProcessHandler();
  if (processHandler != null && !processHandler.isProcessTerminated()) {
    scheduleRestartOnTermination(descriptor, processHandler, modificationStamp, documentWatcher);
  }
  else {
    restart(descriptor);
  }
}
 

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
@Override
public void stop() {
  ProcessHandler processHandler = myDebugProcess.getProcessHandler();
  if (processHandler.isProcessTerminated() || processHandler.isProcessTerminating()) return;

  if (processHandler.detachIsDefault()) {
    processHandler.detachProcess();
  }
  else {
    processHandler.destroyProcess();
  }
}
 

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
private static boolean askForClosingDebugSessions(@NotNull Project project) {
  final List<Pair<ProcessHandler, RunContentDescriptor>> pairs = new ArrayList<Pair<ProcessHandler, RunContentDescriptor>>();

  for (Project p : ProjectManager.getInstance().getOpenProjects()) {
    final ProcessHandler[] processes = ExecutionManager.getInstance(p).getRunningProcesses();

    for (ProcessHandler process : processes) {
      if (!process.isProcessTerminated()) {
        final AndroidSessionInfo info = process.getUserData(AndroidDebugRunner.ANDROID_SESSION_INFO);
        if (info != null) {
          pairs.add(Pair.create(process, info.getDescriptor()));
        }
      }
    }
  }

  if (pairs.size() == 0) {
    return true;
  }

  final StringBuilder s = new StringBuilder();

  for (Pair<ProcessHandler, RunContentDescriptor> pair : pairs) {
    if (s.length() > 0) {
      s.append('\n');
    }
    s.append(pair.getSecond().getDisplayName());
  }

  final int r = Messages.showYesNoDialog(project, AndroidBundle.message("android.debug.sessions.will.be.closed", s),
                                         AndroidBundle.message("android.disable.adb.service.title"), Messages.getQuestionIcon());
  return r == Messages.YES;
}
 

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
private boolean isEnabled() {
  if (myModule == null || myModule.isDisposed()) return false;

  final ProcessHandler processHandler = myContentDescriptor.getProcessHandler();
  if (processHandler == null || processHandler.isProcessTerminated()) return false;

  return true;
}
 

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
private boolean closeQuery(boolean modal) {
  final RunContentDescriptor descriptor = getRunContentDescriptorByContent(myContent);
  if (descriptor == null) {
    return true;
  }

  final ProcessHandler processHandler = descriptor.getProcessHandler();
  if (processHandler == null || processHandler.isProcessTerminated() || processHandler.isProcessTerminating()) {
    return true;
  }
  final boolean destroyProcess;
  //noinspection deprecation
  if (processHandler.isSilentlyDestroyOnClose() || Boolean.TRUE.equals(processHandler.getUserData(ProcessHandler.SILENTLY_DESTROY_ON_CLOSE))) {
    destroyProcess = true;
  }
  else {
    //todo[nik] this is a temporary solution for the following problem: some configurations should not allow user to choose between 'terminating' and 'detaching'
    final boolean useDefault = Boolean.TRUE.equals(processHandler.getUserData(ALWAYS_USE_DEFAULT_STOPPING_BEHAVIOUR_KEY));
    final TerminateRemoteProcessDialog.TerminateOption option = new TerminateRemoteProcessDialog.TerminateOption(processHandler.detachIsDefault(), useDefault);
    final int rc = TerminateRemoteProcessDialog.show(myProject, descriptor.getDisplayName(), option);
    if (rc != DialogWrapper.OK_EXIT_CODE) return false;
    destroyProcess = !option.isToBeShown();
  }
  if (destroyProcess) {
    processHandler.destroyProcess();
  }
  else {
    processHandler.detachProcess();
  }
  waitForProcess(descriptor, modal);
  return true;
}
 

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
@NotNull
public List<RunContentDescriptor> getRunningDescriptors(@NotNull Condition<RunnerAndConfigurationSettings> condition) {
  List<RunContentDescriptor> result = new SmartList<RunContentDescriptor>();
  for (Trinity<RunContentDescriptor, RunnerAndConfigurationSettings, Executor> trinity : myRunningConfigurations) {
    if (condition.value(trinity.getSecond())) {
      ProcessHandler processHandler = trinity.getFirst().getProcessHandler();
      if (processHandler != null /*&& !processHandler.isProcessTerminating()*/ && !processHandler.isProcessTerminated()) {
        result.add(trinity.getFirst());
      }
    }
  }
  return result;
}
 

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
public BrowserStarter(@NotNull RunConfiguration runConfiguration,
                      @NotNull StartBrowserSettings settings,
                      @NotNull final ProcessHandler serverProcessHandler) {
  this(runConfiguration, settings, new Computable<Boolean>() {

    @Override
    public Boolean compute() {
      return serverProcessHandler.isProcessTerminating() || serverProcessHandler.isProcessTerminated();
    }
  });
}
 

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
private static boolean canBeStopped(@Nullable RunContentDescriptor descriptor) {
  @Nullable ProcessHandler processHandler = descriptor != null ? descriptor.getProcessHandler() : null;
  return processHandler != null && !processHandler.isProcessTerminated()
         && (!processHandler.isProcessTerminating()
             || processHandler instanceof KillableProcess && ((KillableProcess)processHandler).canKillProcess());
}
 

import com.intellij.execution.process.ProcessHandler; //导入方法依赖的package包/类
private static Runnable createCancelableExecutionProcess(final ProcessHandler processHandler,
                                                         final Function<Object, Boolean> cancelableFun) {
  return new Runnable() {
    private ProgressIndicator myProgressIndicator;
    private final Semaphore mySemaphore = new Semaphore();

    private final Runnable myWaitThread = new Runnable() {
      @Override
      public void run() {
        try {
          processHandler.waitFor();
        }
        finally {
          mySemaphore.up();
        }
      }
    };

    private final Runnable myCancelListener = new Runnable() {
      @Override
      public void run() {
        while (true) {
          if ((myProgressIndicator != null && (myProgressIndicator.isCanceled()
                                               || !myProgressIndicator.isRunning()))
              || (cancelableFun != null && cancelableFun.fun(null).booleanValue())
              || processHandler.isProcessTerminated()) {

            if (!processHandler.isProcessTerminated()) {
              try {
                processHandler.destroyProcess();
              }
              finally {
                mySemaphore.up();
              }
            }
            break;
          }
          try {
            synchronized (this) {
              wait(1000);
            }
          }
          catch (InterruptedException e) {
            //Do nothing
          }
        }
      }
    };

    @Override
    public void run() {
      myProgressIndicator = ProgressManager.getInstance().getProgressIndicator();
      if (myProgressIndicator != null && StringUtil.isEmpty(myProgressIndicator.getText())) {
        myProgressIndicator.setText("Please wait...");
      }

      LOG.assertTrue(myProgressIndicator != null || cancelableFun != null,
                     "Cancelable process must have an opportunity to be canceled!");
      mySemaphore.down();
      ApplicationManager.getApplication().executeOnPooledThread(myWaitThread);
      ApplicationManager.getApplication().executeOnPooledThread(myCancelListener);

      mySemaphore.waitFor();
    }
  };
}