import com.intellij.execution.remote.RemoteConfiguration; //导入依赖的package包/类
private void createRemoteDebug(
    final RunManagerImpl runManager,
    final HybrisProjectDescriptor hybrisProjectDescriptor
) {
    final RemoteConfigurationType remoteConfigurationType = ConfigurationTypeUtil.findConfigurationType(
        RemoteConfigurationType.class);
    final ConfigurationFactory configurationFactory = remoteConfigurationType.getConfigurationFactories()[0];
    final String debugName = HybrisI18NBundleUtils.message("hybris.project.import.run.configuration.remote.debug");
    final RunnerAndConfigurationSettings runner = runManager.createRunConfiguration(
        debugName,
        configurationFactory
    );
    final RemoteConfiguration remoteConfiguration = (RemoteConfiguration) runner.getConfiguration();
    remoteConfiguration.PORT = getDebugPort(hybrisProjectDescriptor);

    ApplicationManager.getApplication().invokeLater(() -> ApplicationManager.getApplication().runWriteAction(() -> {
        runner.setSingleton(true);
        runner.setActivateToolWindowBeforeRun(true);
        runManager.addConfiguration(runner, true);
        runManager.setSelectedConfiguration(runner);
    }));
}
 

import com.intellij.execution.remote.RemoteConfiguration; //导入依赖的package包/类
/**
 * Creates debugging settings for server
 *
 * @param project
 * @param debugPort
 * @param hostname
 * @return
 */
private RunnerAndConfigurationSettings createRunConfiguration(Project project, String debugPort, String hostname) {
    final RemoteConfigurationType remoteConfigurationType = RemoteConfigurationType.getInstance();

    final ConfigurationFactory factory = remoteConfigurationType.getFactory();
    final RunnerAndConfigurationSettings runSettings =
            RunManager.getInstance(project).createRunConfiguration(getRunConfigurationName(debugPort), factory);
    final RemoteConfiguration configuration = (RemoteConfiguration) runSettings.getConfiguration();

    configuration.HOST = hostname;
    configuration.PORT = debugPort;
    configuration.USE_SOCKET_TRANSPORT = true;
    configuration.SERVER_MODE = false;

    return runSettings;
}
 

import com.intellij.execution.remote.RemoteConfiguration; //导入依赖的package包/类
private static RunnerAndConfigurationSettings createRunConfiguration(
    Project project, String debugPort) {
  final RemoteConfigurationType remoteConfigurationType = RemoteConfigurationType.getInstance();

  final ConfigurationFactory factory = remoteConfigurationType.getFactory();
  final RunnerAndConfigurationSettings runSettings =
      RunManager.getInstance(project)
          .createRunConfiguration(getRunConfigurationName(debugPort), factory);
  final RemoteConfiguration configuration = (RemoteConfiguration) runSettings.getConfiguration();

  configuration.HOST = "localhost";
  configuration.PORT = debugPort;
  configuration.USE_SOCKET_TRANSPORT = true;
  configuration.SERVER_MODE = false;

  return runSettings;
}
 

import com.intellij.execution.remote.RemoteConfiguration; //导入依赖的package包/类
private static RunnerAndConfigurationSettings createRunConfiguration(Project project, String debugPort) {
  final RemoteConfigurationType remoteConfigurationType = RemoteConfigurationType.getInstance();

  final ConfigurationFactory factory = remoteConfigurationType.getFactory();
  final RunnerAndConfigurationSettings runSettings =
    RunManager.getInstance(project).createRunConfiguration(getRunConfigurationName(debugPort), factory);
  final RemoteConfiguration configuration = (RemoteConfiguration)runSettings.getConfiguration();

  configuration.HOST = "localhost";
  configuration.PORT = debugPort;
  configuration.USE_SOCKET_TRANSPORT = true;
  configuration.SERVER_MODE = false;

  return runSettings;
}
 

import com.intellij.execution.remote.RemoteConfiguration; //导入依赖的package包/类
public void connectInDebugMode(RunManagerEx runManager) {
    ServerConfiguration serverConfiguration = selectionHandler.getCurrentConfiguration();
    // Create Remote Connection to Server using the IntelliJ Run / Debug Connection
    //AS TODO: It is working but the configuration is listed and made persistent. That is not too bad because
    //AS TODO: after changes a reconnect will update the configuration.
    RemoteConfigurationType remoteConfigurationType = new RemoteConfigurationType();
    RunConfiguration runConfiguration = remoteConfigurationType.getFactory().createTemplateConfiguration(myProject);
    RemoteConfiguration remoteConfiguration = (RemoteConfiguration) runConfiguration;
    // Server means if you are listening. If not you are attaching.
    remoteConfiguration.SERVER_MODE = false;
    remoteConfiguration.USE_SOCKET_TRANSPORT = true;
    remoteConfiguration.HOST = serverConfiguration.getHost();
    remoteConfiguration.PORT = serverConfiguration.getConnectionDebugPort() + "";
    // Set a Name of the Configuration so that it is properly listed.
    remoteConfiguration.setName(serverConfiguration.getName());
    RunnerAndConfigurationSettings configuration = new RunnerAndConfigurationSettingsImpl(
        (RunManagerImpl) runManager,
        runConfiguration,
        false
    );
    runManager.setTemporaryConfiguration(configuration);
    //AS TODO: Make sure that this is the proper way to obtain the DEBUG Executor
    Executor executor = ExecutorRegistry.getInstance().getExecutorById(ToolWindowId.DEBUG);
    ExecutionUtil.runConfiguration(configuration, executor);
    // Update the Modules with the Remote Sling Server
    OsgiClient osgiClient = obtainOSGiClient();
    if(osgiClient != null) {
        BundleStatus status = checkAndUpdateSupportBundle(false);
        if(status != BundleStatus.failed) {
            checkModules(osgiClient);
        }
    }
}
 

import com.intellij.execution.remote.RemoteConfiguration; //导入依赖的package包/类
private static void launchDebugger(final Project project, final GaugeDebugInfo debugInfo) {
    Runnable runnable = () -> {
        final long startTime = System.currentTimeMillis();
        GenericDebuggerRunner basicProgramRunner = new GenericDebuggerRunner();
        RunManagerImpl manager = new RunManagerImpl(project);
        ConfigurationFactory configFactory = RemoteConfigurationType.getInstance().getConfigurationFactories()[0];
        RemoteConfiguration remoteConfig = new RemoteConfiguration(project, configFactory);
        remoteConfig.PORT = debugInfo.getPort();
        remoteConfig.HOST = debugInfo.getHost();
        remoteConfig.USE_SOCKET_TRANSPORT = true;
        remoteConfig.SERVER_MODE = false;
        RunnerAndConfigurationSettingsImpl configuration = new RunnerAndConfigurationSettingsImpl(manager, remoteConfig, false);
        ExecutionEnvironment environment = new ExecutionEnvironment(new DefaultDebugExecutor(), basicProgramRunner, configuration, project);

        boolean debuggerConnected = false;
        // Trying to connect to gauge java for 25 secs. The sleep is because it may take a few seconds for gauge to launch the java process and the jvm to load after that
        while (!debuggerConnected && ((System.currentTimeMillis() - startTime) < 25000)) {
            try {
                Thread.sleep(5000);
                basicProgramRunner.execute(environment);
                debuggerConnected = true;
            } catch (Exception e) {
                System.err.println("Failed to connect debugger. Retrying... : " + e.getMessage());
            }
        }
    };

    ApplicationManager.getApplication().invokeAndWait(runnable, ModalityState.any());
}
 

import com.intellij.execution.remote.RemoteConfiguration; //导入依赖的package包/类
static boolean shouldCreateTask(RunConfiguration configuration) {
  return !(configuration instanceof RemoteConfiguration) && configuration instanceof RunProfileWithCompileBeforeLaunchOption;
}
 

import com.intellij.execution.remote.RemoteConfiguration; //导入依赖的package包/类
public MakeProjectBeforeRunTask createTask(RunConfiguration runConfiguration) {
  return !(runConfiguration instanceof RemoteConfiguration) && runConfiguration instanceof RunProfileWithCompileBeforeLaunchOption
         ? new MakeProjectBeforeRunTask()
         : null;
}
 

import com.intellij.execution.remote.RemoteConfiguration; //导入依赖的package包/类
public MakeBeforeRunTask createTask(RunConfiguration runConfiguration) {
  return !(runConfiguration instanceof RemoteConfiguration) && runConfiguration instanceof RunProfileWithCompileBeforeLaunchOption
         ? new MakeBeforeRunTask()
         : null;
}
 

import com.intellij.execution.remote.RemoteConfiguration; //导入依赖的package包/类
@Override
public MakeBeforeRunTaskNoErrorCheck createTask(RunConfiguration runConfiguration) {
  return !(runConfiguration instanceof RemoteConfiguration) && runConfiguration instanceof RunProfileWithCompileBeforeLaunchOption
         ? new MakeBeforeRunTaskNoErrorCheck()
         : null;
}