use of com.intellij.openapi.externalSystem.model.execution.ExternalTaskExecutionInfo in project intellij-community by JetBrains.
the class AbstractExternalSystemLocalSettings method pruneOutdatedEntries.
private void pruneOutdatedEntries() {
ExternalSystemManager<?, ?, ?, ?, ?> manager = ExternalSystemApiUtil.getManager(myExternalSystemId);
assert manager != null;
Set<String> pathsToForget = ContainerUtilRt.newHashSet();
for (ExternalProjectPojo pojo : myAvailableProjects.get().keySet()) {
pathsToForget.add(pojo.getPath());
}
for (String path : myAvailableTasks.get().keySet()) {
pathsToForget.add(path);
}
for (ExternalTaskExecutionInfo taskInfo : myRecentTasks.get()) {
pathsToForget.add(taskInfo.getSettings().getExternalProjectPath());
}
AbstractExternalSystemSettings<?, ?, ?> settings = manager.getSettingsProvider().fun(myProject);
for (ExternalProjectSettings projectSettings : settings.getLinkedProjectsSettings()) {
pathsToForget.remove(projectSettings.getExternalProjectPath());
}
for (Module module : ModuleManager.getInstance(myProject).getModules()) {
if (!ExternalSystemApiUtil.isExternalSystemAwareModule(myExternalSystemId, module))
continue;
pathsToForget.remove(ExternalSystemApiUtil.getExternalProjectPath(module));
}
if (!pathsToForget.isEmpty()) {
forgetExternalProjects(pathsToForget);
}
}
use of com.intellij.openapi.externalSystem.model.execution.ExternalTaskExecutionInfo in project intellij-community by JetBrains.
the class GradleExecuteTaskAction method actionPerformed.
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
final Project project = e.getRequiredData(CommonDataKeys.PROJECT);
ExecuteGradleTaskHistoryService historyService = ExecuteGradleTaskHistoryService.getInstance(project);
GradleRunTaskDialog dialog = new GradleRunTaskDialog(project, historyService.getHistory());
String lastWorkingDirectory = historyService.getWorkDirectory();
if (lastWorkingDirectory.length() == 0) {
lastWorkingDirectory = obtainAppropriateWorkingDirectory(e);
}
dialog.setWorkDirectory(lastWorkingDirectory);
if (StringUtil.isEmptyOrSpaces(historyService.getCanceledCommand())) {
if (historyService.getHistory().size() > 0) {
dialog.setCommandLine(historyService.getHistory().get(0));
}
} else {
dialog.setCommandLine(historyService.getCanceledCommand());
}
if (!dialog.showAndGet()) {
historyService.setCanceledCommand(dialog.getCommandLine());
return;
}
historyService.setCanceledCommand(null);
String fullCommandLine = dialog.getCommandLine();
fullCommandLine = fullCommandLine.trim();
String workDirectory = dialog.getWorkDirectory();
historyService.addCommand(fullCommandLine, workDirectory);
final ExternalTaskExecutionInfo taskExecutionInfo;
try {
taskExecutionInfo = buildTaskInfo(workDirectory, fullCommandLine);
} catch (CommandLineArgumentException ex) {
final NotificationData notificationData = new NotificationData("<b>Command-line arguments cannot be parsed</b>", "<i>" + fullCommandLine + "</i> \n" + ex.getMessage(), NotificationCategory.WARNING, NotificationSource.TASK_EXECUTION);
notificationData.setBalloonNotification(true);
ExternalSystemNotificationManager.getInstance(project).showNotification(GradleConstants.SYSTEM_ID, notificationData);
return;
}
RunManagerEx runManager = RunManagerEx.getInstanceEx(project);
ExternalSystemUtil.runTask(taskExecutionInfo.getSettings(), taskExecutionInfo.getExecutorId(), project, GradleConstants.SYSTEM_ID);
RunnerAndConfigurationSettings configuration = ExternalSystemUtil.createExternalSystemRunnerAndConfigurationSettings(taskExecutionInfo.getSettings(), project, GradleConstants.SYSTEM_ID);
if (configuration == null)
return;
final RunnerAndConfigurationSettings existingConfiguration = runManager.findConfigurationByName(configuration.getName());
if (existingConfiguration == null) {
runManager.setTemporaryConfiguration(configuration);
} else {
runManager.setSelectedConfiguration(existingConfiguration);
}
}
use of com.intellij.openapi.externalSystem.model.execution.ExternalTaskExecutionInfo in project intellij-community by JetBrains.
the class GradleExecuteTaskAction method buildTaskInfo.
private static ExternalTaskExecutionInfo buildTaskInfo(@NotNull String projectPath, @NotNull String fullCommandLine) throws CommandLineArgumentException {
CommandLineParser gradleCmdParser = new CommandLineParser();
GradleCommandLineOptionsConverter commandLineConverter = new GradleCommandLineOptionsConverter();
commandLineConverter.configure(gradleCmdParser);
ParsedCommandLine parsedCommandLine = gradleCmdParser.parse(ParametersListUtil.parse(fullCommandLine, true));
final Map<String, List<String>> optionsMap = commandLineConverter.convert(parsedCommandLine, new HashMap<>());
final List<String> systemProperties = optionsMap.remove("system-prop");
final String vmOptions = systemProperties == null ? "" : StringUtil.join(systemProperties, entry -> "-D" + entry, " ");
final String scriptParameters = StringUtil.join(optionsMap.entrySet(), entry -> {
final List<String> values = entry.getValue();
final String longOptionName = entry.getKey();
if (values != null && !values.isEmpty()) {
return StringUtil.join(values, entry1 -> "--" + longOptionName + ' ' + entry1, " ");
} else {
return "--" + longOptionName;
}
}, " ");
final List<String> tasks = parsedCommandLine.getExtraArguments();
ExternalSystemTaskExecutionSettings settings = new ExternalSystemTaskExecutionSettings();
settings.setExternalProjectPath(projectPath);
settings.setTaskNames(tasks);
settings.setScriptParameters(scriptParameters);
settings.setVmOptions(vmOptions);
settings.setExternalSystemIdString(GradleConstants.SYSTEM_ID.toString());
return new ExternalTaskExecutionInfo(settings, DefaultRunExecutor.EXECUTOR_ID);
}
use of com.intellij.openapi.externalSystem.model.execution.ExternalTaskExecutionInfo in project intellij-community by JetBrains.
the class ExternalSystemTasksTreeModel method buildTaskInfo.
@NotNull
private ExternalTaskExecutionInfo buildTaskInfo(@NotNull ExternalTaskPojo task) {
ExternalSystemTaskExecutionSettings settings = new ExternalSystemTaskExecutionSettings();
settings.setExternalProjectPath(task.getLinkedExternalProjectPath());
settings.setTaskNames(Collections.singletonList(task.getName()));
settings.setTaskDescriptions(Collections.singletonList(task.getDescription()));
settings.setExternalSystemIdString(myExternalSystemId.toString());
return new ExternalTaskExecutionInfo(settings, DefaultRunExecutor.EXECUTOR_ID);
}
use of com.intellij.openapi.externalSystem.model.execution.ExternalTaskExecutionInfo in project intellij-community by JetBrains.
the class ExternalSystemTasksTree method produce.
@Nullable
@Override
public ExternalTaskExecutionInfo produce() {
TreePath[] selectionPaths = getSelectionPaths();
if (selectionPaths == null || selectionPaths.length == 0) {
return null;
}
Map<String, ExternalTaskExecutionInfo> map = ContainerUtil.newHashMap();
for (TreePath selectionPath : selectionPaths) {
Object component = selectionPath.getLastPathComponent();
if (!(component instanceof ExternalSystemNode)) {
continue;
}
Object element = ((ExternalSystemNode) component).getDescriptor().getElement();
if (element instanceof ExternalTaskExecutionInfo) {
ExternalTaskExecutionInfo taskExecutionInfo = (ExternalTaskExecutionInfo) element;
ExternalSystemTaskExecutionSettings executionSettings = taskExecutionInfo.getSettings();
String key = executionSettings.getExternalSystemIdString() + executionSettings.getExternalProjectPath() + executionSettings.getVmOptions();
ExternalTaskExecutionInfo executionInfo = map.get(key);
if (executionInfo == null) {
ExternalSystemTaskExecutionSettings taskExecutionSettings = new ExternalSystemTaskExecutionSettings();
taskExecutionSettings.setExternalProjectPath(executionSettings.getExternalProjectPath());
taskExecutionSettings.setExternalSystemIdString(executionSettings.getExternalSystemIdString());
taskExecutionSettings.setVmOptions(executionSettings.getVmOptions());
taskExecutionSettings.setScriptParameters(executionSettings.getScriptParameters());
taskExecutionSettings.setExecutionName(executionSettings.getExecutionName());
executionInfo = new ExternalTaskExecutionInfo(taskExecutionSettings, taskExecutionInfo.getExecutorId());
map.put(key, executionInfo);
}
executionInfo.getSettings().getTaskNames().addAll(executionSettings.getTaskNames());
executionInfo.getSettings().getTaskDescriptions().addAll(executionSettings.getTaskDescriptions());
}
}
// Disable tasks execution if it comes from different projects
if (map.values().size() != 1)
return null;
return map.values().iterator().next();
}
Aggregations