@Nullable private String getRemoteAddress(@NotNull ExecutionEnvironment env) { RunnerAndConfigurationSettings runnerAndConfigurationSettings = env.getRunnerAndConfigurationSettings(); if (runnerAndConfigurationSettings == null) { return null; } RunConfiguration configurationSettings = runnerAndConfigurationSettings.getConfiguration(); if (configurationSettings instanceof BallerinaRemoteConfiguration) { BallerinaRemoteConfiguration applicationConfiguration = (BallerinaRemoteConfiguration) configurationSettings; String remoteDebugHost = applicationConfiguration.getRemoteDebugHost(); if (remoteDebugHost.isEmpty()) { return null; } String remoteDebugPort = applicationConfiguration.getRemoteDebugPort(); if (remoteDebugPort.isEmpty()) { return null; } return remoteDebugHost + ":" + remoteDebugPort; } return null; }
@Before public void setUp() { appEngineConfigProvider = spy(new AppEngineLocalRunCloudApiRunConfigurationProvider()); TestConfigurationInfoProvider configurationInfoProvider = new TestConfigurationInfoProvider(); when(mockCommonStrategy.createStartupHelper(configurationInfoProvider)) .thenReturn(mockScriptHelper); when(mockCommonStrategy.createShutdownHelper(configurationInfoProvider)) .thenReturn(mockScriptHelper); when(mockCommonStrategy.getSettingsBean()) .thenReturn(new JavaeeRunConfigurationCommonSettingsBean()); runnerSpecificLocalConfigurationBit = new RunnerSpecificLocalConfigurationBit(new TestConfigurationInfoProvider()); runnerSpecificLocalConfigurationBit.setEnvironmentVariables(new ArrayList<>()); when(mockRunnerAndConfigurationSettings.getConfiguration()).thenReturn(runConfiguration); when(mockRunnerAndConfigurationSettings.getConfigurationSettings(any())) .thenReturn(runnerSpecificLocalConfigurationBit); when(mockRunnerRegistry.getRunner(any(), any())).thenReturn(mockProgramRunner); doReturn(Collections.singletonList(mockRunnerAndConfigurationSettings)) .when(appEngineConfigProvider) .getRunConfigurationsForCloudApis(mockProject); }
if (existingConfigurations != null) { RunConfiguration existingConfiguration = existingConfigurations.getConfiguration();
@Nullable @Override protected RunnerAndConfigurationSettings createConfigurationByElement(Location location, ConfigurationContext configurationContext) { sourceFile = location.getPsiElement().getContainingFile(); if (sourceFile != null && sourceFile.getFileType().getName().toLowerCase().contains("javascript")) { Project project = sourceFile.getProject(); VirtualFile file = sourceFile.getVirtualFile(); RunnerAndConfigurationSettings settings = cloneTemplateConfiguration(project, configurationContext); MongoRunConfiguration runConfiguration = (MongoRunConfiguration) settings.getConfiguration(); runConfiguration.setName(file.getName()); runConfiguration.setScriptPath(file.getPath()); Module module = ModuleUtil.findModuleForPsiElement(location.getPsiElement()); if (module != null) { runConfiguration.setModule(module); } return settings; } return null; }
@Override public T compute() { ConfigurationContext context = createContext( project, psiElement, dataContext); RunnerAndConfigurationSettings settings = context.getConfiguration(); return settings == null ? null : (T) settings.getConfiguration(); } });
protected AbstractMonkeyModuleBasedConfiguration getConfiguration() { if (getEnvironment().getRunnerAndConfigurationSettings() == null) { throw new RuntimeException("runnerAndConfigurationSettings is null"); } final RunConfiguration configuration = getEnvironment().getRunnerAndConfigurationSettings().getConfiguration(); if (configuration == null || !(configuration instanceof AbstractMonkeyModuleBasedConfiguration)) { throw new RuntimeException("runnerAndConfigurationSettings.getConfiguration() is null or wrong type"); } return (AbstractMonkeyModuleBasedConfiguration) configuration; }
private List<CloudDebugProcessState> getBackgroundDebugStates(Project project) { List<CloudDebugProcessState> states = Lists.newArrayList(); RunManager manager = RunManager.getInstance(project); for (final RunnerAndConfigurationSettings config : manager.getAllSettings()) { if (config.getConfiguration() instanceof CloudDebugRunConfiguration) { final CloudDebugRunConfiguration cloudConfig = (CloudDebugRunConfiguration) config.getConfiguration(); CloudDebugProcessState processState = cloudConfig.getProcessState(); if (processState != null && processState.isListenInBackground()) { states.add(processState); } } } return states; }
/** Get all the background snapshot states. */ public List<CloudDebugProcessState> getBackgroundListeningStates() { List<CloudDebugProcessState> states = new ArrayList<CloudDebugProcessState>(); for (Project project : ProjectManager.getInstance().getOpenProjects()) { Set<RunProfile> runningProfiles = getProfilesWithActiveDebugSession(project); RunManager manager = RunManager.getInstance(project); // find all CloudDebugRunConfiguration that do not have active debug sessions but are // listening in the background for (final RunnerAndConfigurationSettings config : manager.getAllSettings()) { if (notRunningConfiguration(runningProfiles, config.getConfiguration())) { if (config.getConfiguration() instanceof CloudDebugRunConfiguration) { final CloudDebugRunConfiguration cloudConfig = (CloudDebugRunConfiguration) config.getConfiguration(); CloudDebugProcessState state = cloudConfig.getProcessState(); if (listensInBackground(state)) { states.add(state); } } } } } return states; }
/** * Enumerates all runconfigurations in this project and returns a serialized form of their process * states. * * @return a serialized form of the debuggee state as known to the client */ @Nullable @Override public CloudDebugProcessStateSerializer.ProjectState getState() { ProjectState projectState = new ProjectState(); if (CloudDebugConfigType.isFeatureEnabled()) { RunManager manager = RunManager.getInstance(project); for (RunnerAndConfigurationSettings config : manager.getAllSettings()) { if (config.getConfiguration() == null) { continue; } if (config.getConfiguration() instanceof CloudDebugRunConfiguration) { final CloudDebugRunConfiguration cloudConfig = (CloudDebugRunConfiguration) config.getConfiguration(); final CloudDebugProcessState state = cloudConfig.getProcessState(); if (state != null) { projectState.configStates.add(new RunConfigState(cloudConfig.getName(), state)); } } } } return projectState; }
private void removeMake(final Project project) { final RunManagerImpl runManager = RunManagerImpl.getInstanceImpl(project); if (runManager == null) { return; } final AntRunConfigurationType antRunConfigurationType = ConfigurationTypeUtil.findConfigurationType( AntRunConfigurationType.class); final ConfigurationFactory configurationFactory = antRunConfigurationType.getConfigurationFactories()[0]; final RunnerAndConfigurationSettings template = runManager.getConfigurationTemplate(configurationFactory); final AntRunConfiguration runConfiguration = (AntRunConfiguration) template.getConfiguration(); runManager.setBeforeRunTasks(runConfiguration, Collections.<BeforeRunTask>emptyList(), false); } }
private XDebugSession createDebugSettingsAndAddToRunnerSettings( List<RunnerAndConfigurationSettings> runnerSettings, boolean isStopped, boolean hasDebugSession, Boolean listenInBackground) { CloudDebugRunConfiguration runConfiguration = mock(CloudDebugRunConfiguration.class); if (listenInBackground != null) { CloudDebugProcessState processState = new CloudDebugProcessState(); processState.setListenInBackground(listenInBackground); when(runConfiguration.getProcessState()).thenReturn(processState); } RunnerAndConfigurationSettings configurationSettings = mock(RunnerAndConfigurationSettings.class); when(configurationSettings.getConfiguration()).thenReturn(runConfiguration); runnerSettings.add(configurationSettings); if (hasDebugSession) { return createMockSession(isStopped, runConfiguration); } else { return null; } }
private void setupDeployRunConfiguration(@NotNull Module module) { RunManager runManager = RunManager.getInstance(module.getProject()); boolean hasExistingDeployConfiguration = runManager .getAllConfigurationsList() .stream() .filter(config -> config instanceof DeployToServerRunConfiguration) .map(config -> ((DeployToServerRunConfiguration) config).getServerType()) .anyMatch(serverType -> serverType instanceof AppEngineCloudType); if (!hasExistingDeployConfiguration) { AppEngineCloudType serverType = ServerType.EP_NAME.findExtension(AppEngineCloudType.class); RemoteServer<AppEngineServerConfiguration> server = ContainerUtil.getFirstItem(RemoteServersManager.getInstance().getServers(serverType)); DeployToServerConfigurationType configurationType = DeployToServerConfigurationTypesRegistrar.getDeployConfigurationType(serverType); ConfigurationFactoryEx factory = configurationType.getFactory(); RunnerAndConfigurationSettings settings = runManager.createRunConfiguration(configurationType.getDisplayName(), factory); DeployToServerRunConfiguration<?, ?> runConfiguration = (DeployToServerRunConfiguration<?, ?>) settings.getConfiguration(); if (server != null) { runConfiguration.setServerName(server.getName()); } runManager.addConfiguration(settings, false /*isShared*/); } }
protected static Module getModule(Project project) { RunnerAndConfigurationSettings settings = CompileAndRunner.pickRunSetting(project, null); if (settings == null) return null; RunConfiguration raw = settings.getConfiguration(); if (raw instanceof ApplicationConfiguration) { ApplicationConfiguration config = (ApplicationConfiguration) raw; JavaRunConfigurationModule configurationModule = config.getConfigurationModule(); return configurationModule.getModule(); } else if (raw instanceof JUnitConfiguration) { JUnitConfiguration config = (JUnitConfiguration) raw; return config.getModules()[0]; // I guess...? } throw new IllegalStateException("Unable to get module for " + project); }
private void setupLocalDevRunConfiguration( Artifact artifact, @NotNull Project project, ModuleRunConfiguration existingConfiguration) { final ApplicationServer appServer = getOrCreateAppServer(); if (appServer != null) { AppEngineLocalServerUltimateConfigurationType configurationType = AppEngineLocalServerUltimateConfigurationType.getInstance(); CommonModel configuration; if (existingConfiguration instanceof CommonModel && ((CommonModel) existingConfiguration).getServerModel() instanceof AppEngineServerModel) { configuration = (CommonModel) existingConfiguration; } else if (RunManager.getInstance(project) .getConfigurationSettingsList(configurationType) .isEmpty()) { final RunnerAndConfigurationSettings settings = J2EEConfigurationFactory.getInstance() .addAppServerConfiguration(project, configurationType.getLocalFactory(), appServer); configuration = (CommonModel) settings.getConfiguration(); } else { configuration = null; } if (artifact != null && configuration != null && configuration.getServerModel() instanceof AppEngineServerModel) { ((AppEngineServerModel) configuration.getServerModel()).setArtifact(artifact); BuildArtifactsBeforeRunTaskProvider.setBuildArtifactBeforeRun( project, configuration, artifact); } } }
project, settings.getConfiguration(), new CompileStatusNotification() { @Override
private void createRemoteDebug( @NotNull final RunManager runManager, @NotNull final HybrisProjectDescriptor hybrisProjectDescriptor ) { final RemoteConfigurationType remoteConfigurationType = ConfigurationTypeUtil.findConfigurationType( RemoteConfigurationType.class); final ConfigurationFactory configurationFactory = remoteConfigurationType.getConfigurationFactories()[0]; final String configurationName = HybrisI18NBundleUtils.message( "hybris.project.import.run.configuration.remote.debug"); if (runManager.findConfigurationByName(configurationName) != null) { return; } final RunnerAndConfigurationSettings runner = runManager.createRunConfiguration( configurationName, 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); })); }
private void setupRunConfiguration(Module module) { final Project project = module.getProject(); final RunManager runManager = RunManager.getInstance(project); final ConfigurationFactory configurationFactory = MonkeyConfigurationType.getInstance().getFactory(); final RunnerAndConfigurationSettings settings = runManager.createRunConfiguration(module.getName(), configurationFactory); final MonkeyModuleBasedConfiguration configuration = (MonkeyModuleBasedConfiguration) settings.getConfiguration(); configuration.setModule(module); configuration.setTargetDeviceId(DEFAULT_TARGET_DEVICE.getId()); runManager.addConfiguration(settings, false); runManager.setSelectedConfiguration(settings); }
@Override public final RunConfiguration clone() { // clone is called for both creation of run configuration and duplication. New run // configurations are cloned from the configuration factory's instance if (this == RunManager.getInstance(getProject()) .getConfigurationTemplate(this.getFactory()) .getConfiguration()) { UsageTrackerService.getInstance() .trackEvent(GctTracking.CLOUD_DEBUGGER_NEW_RUN_CONFIG) .ping(); } final CloudDebugRunConfiguration configuration = (CloudDebugRunConfiguration) super.clone(); configuration.setCloudProjectId(getCloudProjectId()); return configuration; }
@Override public void setupRootModel(final ModifiableRootModel rootModel) throws ConfigurationException { super.setupRootModel(rootModel); final Project project = rootModel.getProject(); final RunManagerImpl runManager = RunManagerImpl.getInstanceImpl(project); if (dubBinary != null) { ToolKey.DUB_KEY.setPath(dubBinary); } //Create "Run dub" configuration RunnerAndConfigurationSettings runDubSettings = runManager.findConfigurationByName(RUN_DUB_CONFIG_NAME); if (runDubSettings == null) { final DlangRunDubConfigurationType configurationType = Extensions.findExtension(ConfigurationType.CONFIGURATION_TYPE_EP, DlangRunDubConfigurationType.class); final ConfigurationFactory factory = configurationType.getConfigurationFactories()[0]; runDubSettings = runManager.createRunConfiguration(RUN_DUB_CONFIG_NAME, factory); ((ModuleBasedConfiguration) runDubSettings.getConfiguration()).setModule(rootModel.getModule()); runManager.addConfiguration(runDubSettings, false); } }
private static void setupDeploymentRunConfiguration(Module module) { RunManager runManager = RunManager.getInstance(module.getProject()); if (!hasFlexibleDeploymentConfiguration(runManager.getAllConfigurationsList())) { AppEngineCloudType serverType = ServerType.EP_NAME.findExtension(AppEngineCloudType.class); DeployToServerConfigurationType configurationType = DeployToServerConfigurationTypesRegistrar.getDeployConfigurationType(serverType); RunnerAndConfigurationSettings settings = runManager.createRunConfiguration( configurationType.getDisplayName(), configurationType.getFactory()); // Sets the GAE Flex server, if any exists, in the run config. DeployToServerRunConfiguration<?, AppEngineDeploymentConfiguration> runConfiguration = (DeployToServerRunConfiguration<?, AppEngineDeploymentConfiguration>) settings.getConfiguration(); RemoteServer<AppEngineServerConfiguration> server = ContainerUtil.getFirstItem(RemoteServersManager.getInstance().getServers(serverType)); if (server != null) { runConfiguration.setServerName(server.getName()); } runManager.addConfiguration(settings, false /* shared */); } }