use of org.jetbrains.plugins.gradle.service.execution.UnsupportedCancellationToken in project intellij-community by JetBrains.
the class GradleProjectResolver method doResolveProjectInfo.
@NotNull
private DataNode<ProjectData> doResolveProjectInfo(@NotNull final DefaultProjectResolverContext resolverCtx, @NotNull final GradleProjectResolverExtension projectResolverChain, boolean isBuildSrcProject) throws IllegalArgumentException, IllegalStateException {
final BuildEnvironment buildEnvironment = GradleExecutionHelper.getBuildEnvironment(resolverCtx.getConnection());
GradleVersion gradleVersion = null;
boolean isGradleProjectDirSupported = false;
boolean isCompositeBuildsSupported = false;
if (buildEnvironment != null) {
gradleVersion = GradleVersion.version(buildEnvironment.getGradle().getGradleVersion());
isGradleProjectDirSupported = gradleVersion.compareTo(GradleVersion.version("2.4")) >= 0;
isCompositeBuildsSupported = isGradleProjectDirSupported && gradleVersion.compareTo(GradleVersion.version("3.1")) >= 0;
}
final ProjectImportAction projectImportAction = new ProjectImportAction(resolverCtx.isPreviewMode(), isGradleProjectDirSupported, isCompositeBuildsSupported);
GradleExecutionSettings executionSettings = resolverCtx.getSettings();
if (executionSettings == null) {
executionSettings = new GradleExecutionSettings(null, null, DistributionType.BUNDLED, false);
}
executionSettings.withArgument("-Didea.version=" + getIdeaVersion());
if (resolverCtx.isPreviewMode()) {
executionSettings.withArgument("-Didea.isPreviewMode=true");
final Set<Class> previewLightWeightToolingModels = ContainerUtil.set(ExternalProjectPreview.class, GradleBuild.class);
projectImportAction.addExtraProjectModelClasses(previewLightWeightToolingModels);
}
if (resolverCtx.isResolveModulePerSourceSet()) {
executionSettings.withArgument("-Didea.resolveSourceSetDependencies=true");
}
if (!isBuildSrcProject) {
for (GradleBuildParticipant buildParticipant : executionSettings.getExecutionWorkspace().getBuildParticipants()) {
executionSettings.withArguments(GradleConstants.INCLUDE_BUILD_CMD_OPTION, buildParticipant.getProjectPath());
}
}
final Set<Class> toolingExtensionClasses = ContainerUtil.newHashSet();
final GradleImportCustomizer importCustomizer = GradleImportCustomizer.get();
for (GradleProjectResolverExtension resolverExtension = projectResolverChain; resolverExtension != null; resolverExtension = resolverExtension.getNext()) {
// inject ProjectResolverContext into gradle project resolver extensions
resolverExtension.setProjectResolverContext(resolverCtx);
// pre-import checks
resolverExtension.preImportCheck();
if (!resolverCtx.isPreviewMode()) {
// register classes of extra gradle project models required for extensions (e.g. com.android.builder.model.AndroidProject)
projectImportAction.addExtraProjectModelClasses(resolverExtension.getExtraProjectModelClasses());
}
if (importCustomizer == null || importCustomizer.useExtraJvmArgs()) {
// collect extra JVM arguments provided by gradle project resolver extensions
final ParametersList parametersList = new ParametersList();
for (Pair<String, String> jvmArg : resolverExtension.getExtraJvmArgs()) {
parametersList.addProperty(jvmArg.first, jvmArg.second);
}
executionSettings.withVmOptions(parametersList.getParameters());
}
// collect extra command-line arguments
executionSettings.withArguments(resolverExtension.getExtraCommandLineArgs());
// collect tooling extensions classes
toolingExtensionClasses.addAll(resolverExtension.getToolingExtensionsClasses());
}
BuildActionExecuter<ProjectImportAction.AllModels> buildActionExecutor = resolverCtx.getConnection().action(projectImportAction);
File initScript = GradleExecutionHelper.generateInitScript(isBuildSrcProject, toolingExtensionClasses);
if (initScript != null) {
executionSettings.withArguments(GradleConstants.INIT_SCRIPT_CMD_OPTION, initScript.getAbsolutePath());
}
GradleExecutionHelper.prepare(buildActionExecutor, resolverCtx.getExternalSystemTaskId(), executionSettings, resolverCtx.getListener(), resolverCtx.getConnection());
resolverCtx.checkCancelled();
ProjectImportAction.AllModels allModels;
final CancellationTokenSource cancellationTokenSource = GradleConnector.newCancellationTokenSource();
final long startTime = System.currentTimeMillis();
try {
resolverCtx.setCancellationTokenSource(cancellationTokenSource);
buildActionExecutor.withCancellationToken(cancellationTokenSource.token());
synchronized (myCancellationMap) {
myCancellationMap.putValue(resolverCtx.getExternalSystemTaskId(), cancellationTokenSource);
if (gradleVersion != null && gradleVersion.compareTo(GradleVersion.version("2.1")) < 0) {
myCancellationMap.putValue(resolverCtx.getExternalSystemTaskId(), new UnsupportedCancellationToken());
}
}
allModels = buildActionExecutor.run();
if (allModels == null) {
throw new IllegalStateException("Unable to get project model for the project: " + resolverCtx.getProjectPath());
}
} catch (UnsupportedVersionException unsupportedVersionException) {
resolverCtx.checkCancelled();
// Old gradle distribution version used (before ver. 1.8)
// fallback to use ModelBuilder gradle tooling API
Class<? extends IdeaProject> aClass = resolverCtx.isPreviewMode() ? BasicIdeaProject.class : IdeaProject.class;
ModelBuilder<? extends IdeaProject> modelBuilder = myHelper.getModelBuilder(aClass, resolverCtx.getExternalSystemTaskId(), executionSettings, resolverCtx.getConnection(), resolverCtx.getListener());
final IdeaProject ideaProject = modelBuilder.get();
allModels = new ProjectImportAction.AllModels(ideaProject);
} finally {
final long timeInMs = (System.currentTimeMillis() - startTime);
synchronized (myCancellationMap) {
myCancellationMap.remove(resolverCtx.getExternalSystemTaskId(), cancellationTokenSource);
}
LOG.debug(String.format("Gradle data obtained in %d ms", timeInMs));
}
resolverCtx.checkCancelled();
allModels.setBuildEnvironment(buildEnvironment);
final long startDataConversionTime = System.currentTimeMillis();
extractExternalProjectModels(allModels, resolverCtx);
// import project data
ProjectData projectData = projectResolverChain.createProject();
DataNode<ProjectData> projectDataNode = new DataNode<>(ProjectKeys.PROJECT, projectData, null);
// import java project data
JavaProjectData javaProjectData = projectResolverChain.createJavaProjectData();
projectDataNode.createChild(JavaProjectData.KEY, javaProjectData);
IdeaProject ideaProject = resolverCtx.getModels().getIdeaProject();
projectResolverChain.populateProjectExtraModels(ideaProject, projectDataNode);
DomainObjectSet<? extends IdeaModule> gradleModules = ideaProject.getModules();
if (gradleModules == null || gradleModules.isEmpty()) {
throw new IllegalStateException("No modules found for the target project: " + ideaProject);
}
Collection<IdeaModule> includedModules = exposeCompositeBuild(allModels, resolverCtx, projectDataNode);
final Map<String, Pair<DataNode<ModuleData>, IdeaModule>> /* module id */
moduleMap = ContainerUtilRt.newHashMap();
final Map<String, Pair<DataNode<GradleSourceSetData>, ExternalSourceSet>> /* module id */
sourceSetsMap = ContainerUtil.newHashMap();
projectDataNode.putUserData(RESOLVED_SOURCE_SETS, sourceSetsMap);
final Map<String, Pair<String, ExternalSystemSourceType>> /* module id*/
moduleOutputsMap = ContainerUtil.newTroveMap(FileUtil.PATH_HASHING_STRATEGY);
projectDataNode.putUserData(MODULES_OUTPUTS, moduleOutputsMap);
final Map<String, String> /* module id*/
artifactsMap = ContainerUtil.newTroveMap(FileUtil.PATH_HASHING_STRATEGY);
projectDataNode.putUserData(CONFIGURATION_ARTIFACTS, artifactsMap);
// import modules data
for (IdeaModule gradleModule : ContainerUtil.concat(gradleModules, includedModules)) {
if (gradleModule == null) {
continue;
}
resolverCtx.checkCancelled();
if (ExternalSystemDebugEnvironment.DEBUG_ORPHAN_MODULES_PROCESSING) {
LOG.info(String.format("Importing module data: %s", gradleModule));
}
final String moduleName = gradleModule.getName();
if (moduleName == null) {
throw new IllegalStateException("Module with undefined name detected: " + gradleModule);
}
DataNode<ModuleData> moduleDataNode = projectResolverChain.createModule(gradleModule, projectDataNode);
String mainModuleId = getModuleId(resolverCtx, gradleModule);
if (moduleMap.containsKey(mainModuleId)) {
// we should ensure deduplicated module names in the scope of single import
throw new IllegalStateException("Duplicate modules names detected: " + gradleModule);
}
moduleMap.put(mainModuleId, Pair.create(moduleDataNode, gradleModule));
}
executionSettings.getExecutionWorkspace().addModuleMap(moduleMap);
File gradleHomeDir = null;
// populate modules nodes
for (final Pair<DataNode<ModuleData>, IdeaModule> pair : moduleMap.values()) {
final DataNode<ModuleData> moduleDataNode = pair.first;
final IdeaModule ideaModule = pair.second;
if (gradleHomeDir == null) {
final BuildScriptClasspathModel buildScriptClasspathModel = resolverCtx.getExtraProject(ideaModule, BuildScriptClasspathModel.class);
if (buildScriptClasspathModel != null) {
gradleHomeDir = buildScriptClasspathModel.getGradleHomeDir();
}
}
projectResolverChain.populateModuleContentRoots(ideaModule, moduleDataNode);
projectResolverChain.populateModuleCompileOutputSettings(ideaModule, moduleDataNode);
if (!isBuildSrcProject) {
projectResolverChain.populateModuleTasks(ideaModule, moduleDataNode, projectDataNode);
}
final List<DataNode<? extends ModuleData>> modules = ContainerUtil.newSmartList();
modules.add(moduleDataNode);
modules.addAll(ExternalSystemApiUtil.findAll(moduleDataNode, GradleSourceSetData.KEY));
final ExternalSystemSourceType[] sourceTypes = new ExternalSystemSourceType[] { ExternalSystemSourceType.SOURCE, ExternalSystemSourceType.RESOURCE, ExternalSystemSourceType.TEST, ExternalSystemSourceType.TEST_RESOURCE };
for (DataNode<? extends ModuleData> module : modules) {
final ModuleData moduleData = module.getData();
for (ExternalSystemSourceType sourceType : sourceTypes) {
final String path = moduleData.getCompileOutputPath(sourceType);
if (path != null) {
moduleOutputsMap.put(path, Pair.create(moduleData.getId(), sourceType));
}
}
if (moduleData instanceof GradleSourceSetData) {
for (File artifactFile : moduleData.getArtifacts()) {
artifactsMap.put(ExternalSystemApiUtil.toCanonicalPath(artifactFile.getAbsolutePath()), moduleData.getId());
}
}
}
}
for (final Pair<DataNode<ModuleData>, IdeaModule> pair : moduleMap.values()) {
final DataNode<ModuleData> moduleDataNode = pair.first;
final IdeaModule ideaModule = pair.second;
projectResolverChain.populateModuleDependencies(ideaModule, moduleDataNode, projectDataNode);
projectResolverChain.populateModuleExtraModels(ideaModule, moduleDataNode);
}
mergeSourceSetContentRoots(moduleMap, resolverCtx);
if (resolverCtx.isResolveModulePerSourceSet()) {
mergeLibraryAndModuleDependencyData(projectDataNode, gradleHomeDir, gradleVersion);
}
projectDataNode.putUserData(RESOLVED_SOURCE_SETS, null);
projectDataNode.putUserData(MODULES_OUTPUTS, null);
projectDataNode.putUserData(CONFIGURATION_ARTIFACTS, null);
// ensure unique library names
Collection<DataNode<LibraryData>> libraries = ExternalSystemApiUtil.getChildren(projectDataNode, ProjectKeys.LIBRARY);
myLibraryNamesMixer.mixNames(libraries);
final long timeConversionInMs = (System.currentTimeMillis() - startDataConversionTime);
LOG.debug(String.format("Project data resolved in %d ms", timeConversionInMs));
return projectDataNode;
}
use of org.jetbrains.plugins.gradle.service.execution.UnsupportedCancellationToken in project intellij-community by JetBrains.
the class GradleTaskManager method executeTasks.
@Override
public void executeTasks(@NotNull final ExternalSystemTaskId id, @NotNull final List<String> taskNames, @NotNull String projectPath, @Nullable GradleExecutionSettings settings, @Nullable final String jvmAgentSetup, @NotNull final ExternalSystemTaskNotificationListener listener) throws ExternalSystemException {
// TODO add support for external process mode
if (ExternalSystemApiUtil.isInProcessMode(GradleConstants.SYSTEM_ID)) {
for (GradleTaskManagerExtension gradleTaskManagerExtension : GradleTaskManagerExtension.EP_NAME.getExtensions()) {
if (gradleTaskManagerExtension.executeTasks(id, taskNames, projectPath, settings, jvmAgentSetup, listener)) {
return;
}
}
}
GradleExecutionSettings effectiveSettings = settings == null ? new GradleExecutionSettings(null, null, DistributionType.BUNDLED, false) : settings;
Function<ProjectConnection, Void> f = connection -> {
final List<String> initScripts = ContainerUtil.newArrayList();
final GradleProjectResolverExtension projectResolverChain = GradleProjectResolver.createProjectResolverChain(effectiveSettings);
for (GradleProjectResolverExtension resolverExtension = projectResolverChain; resolverExtension != null; resolverExtension = resolverExtension.getNext()) {
final String resolverClassName = resolverExtension.getClass().getName();
resolverExtension.enhanceTaskProcessing(taskNames, jvmAgentSetup, script -> {
if (StringUtil.isNotEmpty(script)) {
ContainerUtil.addAllNotNull(initScripts, "//-- Generated by " + resolverClassName, script, "//");
}
});
}
final String initScript = effectiveSettings.getUserData(INIT_SCRIPT_KEY);
if (StringUtil.isNotEmpty(initScript)) {
ContainerUtil.addAll(initScripts, "//-- Additional script", initScript, "//");
}
if (!initScripts.isEmpty()) {
try {
File tempFile = GradleExecutionHelper.writeToFileGradleInitScript(StringUtil.join(initScripts, SystemProperties.getLineSeparator()));
effectiveSettings.withArguments(GradleConstants.INIT_SCRIPT_CMD_OPTION, tempFile.getAbsolutePath());
} catch (IOException e) {
throw new ExternalSystemException(e);
}
}
GradleVersion gradleVersion = GradleExecutionHelper.getGradleVersion(connection);
if (gradleVersion != null && gradleVersion.compareTo(GradleVersion.version("2.5")) < 0) {
listener.onStatusChange(new ExternalSystemTaskExecutionEvent(id, new ExternalSystemProgressEventUnsupportedImpl(gradleVersion + " does not support executions view")));
}
for (GradleBuildParticipant buildParticipant : effectiveSettings.getExecutionWorkspace().getBuildParticipants()) {
effectiveSettings.withArguments(GradleConstants.INCLUDE_BUILD_CMD_OPTION, buildParticipant.getProjectPath());
}
BuildLauncher launcher = myHelper.getBuildLauncher(id, connection, effectiveSettings, listener);
launcher.forTasks(ArrayUtil.toStringArray(taskNames));
if (gradleVersion != null && gradleVersion.compareTo(GradleVersion.version("2.1")) < 0) {
myCancellationMap.put(id, new UnsupportedCancellationToken());
} else {
final CancellationTokenSource cancellationTokenSource = GradleConnector.newCancellationTokenSource();
launcher.withCancellationToken(cancellationTokenSource.token());
myCancellationMap.put(id, cancellationTokenSource);
}
try {
launcher.run();
} finally {
myCancellationMap.remove(id);
}
return null;
};
myHelper.execute(projectPath, effectiveSettings, f);
}
Aggregations