Java RunProfileState類代碼示例

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
@Nullable
protected RunContentDescriptor attachVirtualMachine(final RunProfileState state, final @NotNull ExecutionEnvironment env)
        throws ExecutionException
{

    return XDebuggerManager.getInstance(env.getProject()).startSession(env, new XDebugProcessStarter()
    {
        @NotNull
        public XDebugProcess start(@NotNull XDebugSession session) throws ExecutionException
        {
            WeaveRunnerCommandLine weaveRunnerCommandLine = (WeaveRunnerCommandLine) state;
            final String weaveFile = weaveRunnerCommandLine.getModel().getWeaveFile();
            final Project project = weaveRunnerCommandLine.getEnvironment().getProject();
            final VirtualFile projectFile = project.getBaseDir();
            final String path = project.getBasePath();
            final String relativePath = weaveFile.substring(path.length());
            final VirtualFile fileByRelativePath = projectFile.findFileByRelativePath(relativePath);
            final DebuggerClient localhost = new DebuggerClient(new WeaveDebuggerClientListener(session, fileByRelativePath), new TcpClientDebuggerProtocol("localhost", 6565));
            final ExecutionResult result = state.execute(env.getExecutor(), WeaveDebuggerRunner.this);
            new DebuggerConnector(localhost).start();
            return new WeaveDebugProcess(session, localhost, result);
        }
    }).getRunContentDescriptor();

}
 

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
@Nullable
@Override
protected RunContentDescriptor createContentDescriptor(@NotNull RunProfileState state, @NotNull ExecutionEnvironment environment) throws ExecutionException {
  if (state instanceof ExternalSystemRunConfiguration.MyRunnableState) {
    int port = ((ExternalSystemRunConfiguration.MyRunnableState)state).getDebugPort();
    if (port > 0) {
      RemoteConnection connection = new RemoteConnection(true, "127.0.0.1", String.valueOf(port), true);
      return attachVirtualMachine(state, environment, connection, true);
    }
    else {
      LOG.warn("Can't attach debugger to external system task execution. Reason: target debug port is unknown");
    }
  }
  else {
    LOG.warn(String.format(
      "Can't attach debugger to external system task execution. Reason: invalid run profile state is provided"
      + "- expected '%s' but got '%s'",
      ExternalSystemRunConfiguration.MyRunnableState.class.getName(), state.getClass().getName()
    ));
  }
  return null;
}
 

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
public RemoteExternalSystemCommunicationManager(@NotNull ExternalSystemProgressNotificationManager notificationManager) {
  myProgressManager = (ExternalSystemProgressNotificationManagerImpl)notificationManager;
  mySupport = new RemoteProcessSupport<Object, RemoteExternalSystemFacade, String>(RemoteExternalSystemFacade.class) {
    @Override
    protected void fireModificationCountChanged() {
    }

    @Override
    protected String getName(Object o) {
      return RemoteExternalSystemFacade.class.getName();
    }

    @Override
    protected RunProfileState getRunProfileState(Object o, String configuration, Executor executor) throws ExecutionException {
      return createRunProfileState(configuration);
    }
  };

  ShutDownTracker.getInstance().registerShutdownTask(new Runnable() {
    public void run() {
      shutdown(false);
    }
  });
}
 

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
@Override
protected final void execute(@NotNull final ExecutionEnvironment environment,
                             @Nullable final Callback callback,
                             @NotNull final RunProfileState state) throws ExecutionException {
  prepare(environment, state)
    .done(new Consumer<RunProfileStarter>() {
      @Override
      public void consume(@Nullable final RunProfileStarter result) {
        UIUtil.invokeLaterIfNeeded(new Runnable() {
          @Override
          public void run() {
            if (!environment.getProject().isDisposed()) {
              startRunProfile(environment, state, callback, result);
            }
          }
        });
      }
    });
}
 

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
@Override
protected void initSession(XDebugSession session, RunProfileState state, Executor executor) {
  XDebugSessionTab tab = ((XDebugSessionImpl)session).getSessionTab();
  if (tab != null) {
    RunnerLayoutUi ui = tab.getUi();
    ContentManager contentManager = ui.getContentManager();
    Content content = findContent(contentManager, XDebuggerBundle.message("debugger.session.tab.watches.title"));
    if (content != null) {
      contentManager.removeContent(content, true);
    }
    content = findContent(contentManager, XDebuggerBundle.message("debugger.session.tab.console.content.name"));
    if (content != null) {
      contentManager.removeContent(content, true);
    }
    initEduConsole(session, ui);
  }
}
 

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
@Nullable
@Override
public RunProfileState getState(@NotNull Executor executor, @NotNull ExecutionEnvironment env) throws ExecutionException {
  final AbstractPythonRunConfiguration configuration = ((AbstractPythonRunConfiguration)getPeer());

  // If configuration wants to take care about rerun itself
  if (configuration instanceof TestRunConfigurationReRunResponsible) {
    // TODO: Extract method
    final Set<PsiElement> failedTestElements = new HashSet<PsiElement>();
    for (final AbstractTestProxy proxy : getFailedTests(getProject())) {
      final Location<?> location = proxy.getLocation(getProject(), GlobalSearchScope.allScope(getProject()));
      if (location != null) {
        failedTestElements.add(location.getPsiElement());
      }
    }
    return ((TestRunConfigurationReRunResponsible)configuration).rerunTests(executor, env, failedTestElements);
  }
  return new FailedPythonTestCommandLineStateBase(configuration, env,
                                                  (PythonTestCommandLineStateBase)configuration.getState(executor, env));
}
 

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
/**
 * Searches for "rerun failed tests" action and fetches state from it
 *
 * @param descriptor previous run descriptor
 * @return state (if found)
 */
@Nullable
public static RunProfileState findRestartActionState(@NotNull final RunContentDescriptor descriptor) {
  final ExecutionEnvironment action = findRestartAction(descriptor);
  if (action == null) {
    return null;
  }
  final Ref<RunProfileState> stateRef = new Ref<RunProfileState>();
  ApplicationManager.getApplication().invokeAndWait(new Runnable() {
    @Override
    public void run() {
      try {
        stateRef.set(action.getState());
      }
      catch (final ExecutionException e) {
        throw new IllegalStateException("Error obtaining execution state", e);
      }
    }
  }, ModalityState.NON_MODAL);

  return stateRef.get();
}
 

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
@Override
protected RunContentDescriptor doExecute(@NotNull final RunProfileState state, @NotNull final ExecutionEnvironment environment) throws ExecutionException {
  assert state instanceof AndroidRunningState;
  final AndroidRunningState runningState = (AndroidRunningState)state;
  final RunContentDescriptor[] descriptor = {null};

  runningState.addListener(new AndroidRunningStateListener() {
    @Override
    public void executionFailed() {
      ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
          if (descriptor[0] != null) {
            showNotification(environment.getProject(), environment.getExecutor(), descriptor[0], "error", false, NotificationType.ERROR);
          }
        }
      });
    }
  });
  descriptor[0] = doExec(runningState, environment);
  return descriptor[0];
}
 

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
@Override
protected MyRunProfile getRunProfile(@NotNull ExecutionEnvironment environment) {
  //noinspection ConstantConditions
  final JUnitConfiguration configuration = (JUnitConfiguration)myConsoleProperties.getConfiguration();
  final TestMethods testMethods = new TestMethods(configuration, environment, getFailedTests(configuration.getProject()));
  return new MyRunProfile(configuration) {
    @Override
    @NotNull
    public Module[] getModules() {
      return testMethods.getModulesToCompile();
    }

    @Override
    public RunProfileState getState(@NotNull Executor executor, @NotNull ExecutionEnvironment env) {
      testMethods.clear();
      return testMethods;
    }
  };
}
 

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
protected RunContentDescriptor createContentDescriptor(final RunProfileState runProfileState, final ExecutionEnvironment environment) throws ExecutionException {
  final XDebugSession debugSession =
    XDebuggerManager.getInstance(environment.getProject()).startSession(environment, new XDebugProcessStarter() {
      @NotNull
      public XDebugProcess start(@NotNull final XDebugSession session) throws ExecutionException {
        ACTIVE.set(Boolean.TRUE);
        try {
          final XsltCommandLineState c = (XsltCommandLineState)runProfileState;
          final ExecutionResult result = runProfileState.execute(environment.getExecutor(), XsltDebuggerRunner.this);
          return new XsltDebugProcess(session, result, c.getExtensionData().getUserData(XsltDebuggerExtension.VERSION));
        } finally {
          ACTIVE.remove();
        }
      }
    });
  return debugSession.getRunContentDescriptor();
}
 

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
@Override
protected RunContentDescriptor doExecute(
    final RunProfileState state, final ExecutionEnvironment env) throws ExecutionException {
  RunContentDescriptor descriptor = super.doExecute(state, env);
  if (descriptor != null) {
    ProcessHandler processHandler = descriptor.getProcessHandler();
    assert processHandler != null;

    RunProfile runProfile = env.getRunProfile();
    int uniqueId =
        (runProfile instanceof RunConfigurationBase)
            ? ((RunConfigurationBase) runProfile).getUniqueID()
            : -1;
    AndroidSessionInfo sessionInfo =
        new AndroidSessionInfo(
            processHandler,
            descriptor,
            uniqueId,
            env.getExecutor().getId(),
            env.getExecutor().getActionName(),
            InstantRunUtils.isInstantRunEnabled(env));
    processHandler.putUserData(AndroidSessionInfo.KEY, sessionInfo);
  }

  return descriptor;
}
 

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
@Nullable
@Override
protected RunContentDescriptor doExecute(@NotNull RunProfileState state, @NotNull ExecutionEnvironment environment) throws ExecutionException {
    if(DEBUG_EXECUTOR.equals(environment.getExecutor().getId())) {
        RoboVmRunConfiguration runConfig = (RoboVmRunConfiguration)environment.getRunProfile();
        RemoteConnection connection = new RemoteConnection(true, "127.0.0.1", "" + runConfig.getDebugPort(), false);
        connection.setServerMode(true);
        return attachVirtualMachine(state, environment, connection, false);
    } else {
        ExecutionResult executionResult = state.execute(environment.getExecutor(), this);
        if (executionResult == null) {
            return null;
        }
        return new RunContentBuilder(executionResult, environment).showRunContent(environment.getContentToReuse());
    }
}
 

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
@Nullable
@Override
protected RunContentDescriptor doExecute(@NotNull Project project, @NotNull RunProfileState state,
                                         @Nullable RunContentDescriptor contentToReuse, @NotNull ExecutionEnvironment environment) throws ExecutionException {
    final MayaCharmRunProfile configuration = (MayaCharmRunProfile) environment.getRunProfile();
    final MCSettingsProvider settingsProvider = MCSettingsProvider.getInstance(project);
    final MayaCommInterface mayaCommInterface = new MayaCommInterface(settingsProvider.getHost(), settingsProvider.getPort());

    ToolWindow mayaLogWindow = ToolWindowManager.getInstance(project).getToolWindow("Maya Log");
    mayaLogWindow.activate(null, true, true);

    mayaCommInterface.connectMayaLog();

    switch (configuration.getExecutionType()) {
        case CODE:
            mayaCommInterface.sendCodeToMaya(configuration.getScriptCodeText());
            break;
        case FILE:
            mayaCommInterface.sendFileToMaya(configuration.getScriptFilePath());
            break;
    }
    return null;
}
 

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
@Override
@RequiredDispatchThread
protected RunContentDescriptor doExecute(@NotNull RunProfileState state, @NotNull ExecutionEnvironment env) throws ExecutionException
{
	UnityProcess editorProcess = UnityEditorCommunication.findEditorProcess();
	if(editorProcess == null)
	{
		throw new ExecutionException("Editor is not responding");
	}
	FileDocumentManager.getInstance().saveAllDocuments();

	ExecutionResult executionResult = state.execute(env.getExecutor(), this);
	if(executionResult == null)
	{
		return null;
	}
	return Unity3dAttachRunner.runContentDescriptor(executionResult, env, editorProcess, (ConsoleView) executionResult.getExecutionConsole(), true);
}
 

import com.intellij.execution.configurations.RunProfileState; //導入依賴的package包/類
@Override
public RunProfileState getState(@NotNull Executor executor, final @NotNull ExecutionEnvironment env) throws ExecutionException {
    if (DefaultDebugExecutor.EXECUTOR_ID.equals(executor.getId())) {
        List<String> goals = null;
        if (RunType.Test.equals(runType)) {
            RunnerAndConfigurationSettings settings = env.getRunnerAndConfigurationSettings();
            if (settings != null && settings.getConfiguration() instanceof MvnRunConfiguration) {
                goals = disableFork(((MvnRunConfiguration) settings.getConfiguration()).getGoals());
            }
        }
        if ((RunType.Jetty.equals(runType) || RunType.Tomcat.equals(runType)) || goals != null) {
            return new DebugServerCommandLineState(env, this, goals);
        }
    }
    return super.getState(executor, env);
}