From 58ec2ea76b3ab08f08713e0c08201e8269c51b84 Mon Sep 17 00:00:00 2001 From: Mat Booth Date: Apr 01 2020 13:48:15 +0000 Subject: Add patch to fix NoClassDefFoundErrors --- diff --git a/core.patch b/core.patch new file mode 100644 index 0000000..1ddfa4e --- /dev/null +++ b/core.patch @@ -0,0 +1,576 @@ +diff -ur '--exclude=pom.xml' '--exclude=MANIFEST.MF' --new-file m2e-core-8328691915d0e67544c97597b0ea02d559f0f4ea-new/org.eclipse.m2e.core/src/org/eclipse/m2e/core/internal/builder/MavenBuilder.java m2e-core-c5392da6bab9893bcbf5b43f651abe48d5819bea-old-old/org.eclipse.m2e.core/src/org/eclipse/m2e/core/internal/builder/MavenBuilder.java +--- m2e-core-8328691915d0e67544c97597b0ea02d559f0f4ea-new/org.eclipse.m2e.core/src/org/eclipse/m2e/core/internal/builder/MavenBuilder.java 2020-03-05 13:08:51.000000000 +0000 ++++ m2e-core-c5392da6bab9893bcbf5b43f651abe48d5819bea-old-old/org.eclipse.m2e.core/src/org/eclipse/m2e/core/internal/builder/MavenBuilder.java 2019-03-05 15:19:21.000000000 +0000 +@@ -36,6 +34,7 @@ + import org.apache.maven.project.MavenProject; + + import org.eclipse.m2e.core.MavenPlugin; ++import org.eclipse.m2e.core.embedder.ICallable; + import org.eclipse.m2e.core.embedder.IMavenExecutionContext; + import org.eclipse.m2e.core.internal.IMavenConstants; + import org.eclipse.m2e.core.internal.M2EUtils; +@@ -85,34 +84,39 @@ + + final MavenExecutionContext context = projectManager.createExecutionContext(pomResource, resolverConfiguration); + +- return context.execute((context2, monitor2) -> { +- final IMavenProjectFacade projectFacade = getProjectFacade(project, monitor2); +- +- if(projectFacade == null) { +- return null; +- } +- +- MavenProject mavenProject; +- try { +- // make sure projectFacade has MavenProject instance loaded +- mavenProject = projectFacade.getMavenProject(monitor2); +- } catch(CoreException ce) { +- //unable to read the project facade +- addErrorMarker(project, ce); +- return null; +- } ++ return context.execute(new ICallable() { ++ @Override ++ public T call(IMavenExecutionContext context, IProgressMonitor monitor) throws CoreException { ++ final IMavenProjectFacade projectFacade = getProjectFacade(project, monitor); + +- return context2.execute(mavenProject, (context1, monitor1) -> { +- ILifecycleMapping lifecycleMapping = configurationManager.getLifecycleMapping(projectFacade); +- if(lifecycleMapping == null) { ++ if(projectFacade == null) { + return null; + } + +- Map> buildParticipantsByMojoExecutionKey = lifecycleMapping +- .getBuildParticipants(projectFacade, monitor1); ++ MavenProject mavenProject; ++ try { ++ // make sure projectFacade has MavenProject instance loaded ++ mavenProject = projectFacade.getMavenProject(monitor); ++ } catch(CoreException ce) { ++ //unable to read the project facade ++ addErrorMarker(project, ce); ++ return null; ++ } + +- return method(context1, projectFacade, buildParticipantsByMojoExecutionKey, kind, args, monitor1); +- }, monitor2); ++ return context.execute(mavenProject, new ICallable() { ++ public T call(IMavenExecutionContext context, IProgressMonitor monitor) throws CoreException { ++ ILifecycleMapping lifecycleMapping = configurationManager.getLifecycleMapping(projectFacade); ++ if(lifecycleMapping == null) { ++ return null; ++ } ++ ++ Map> buildParticipantsByMojoExecutionKey = lifecycleMapping ++ .getBuildParticipants(projectFacade, monitor); ++ ++ return method(context, projectFacade, buildParticipantsByMojoExecutionKey, kind, args, monitor); ++ } ++ }, monitor); ++ } + }, monitor); + } + +diff -ur '--exclude=pom.xml' '--exclude=MANIFEST.MF' --new-file m2e-core-8328691915d0e67544c97597b0ea02d559f0f4ea-new/org.eclipse.m2e.core/src/org/eclipse/m2e/core/internal/project/registry/ProjectRegistryManager.java m2e-core-c5392da6bab9893bcbf5b43f651abe48d5819bea-old-old/org.eclipse.m2e.core/src/org/eclipse/m2e/core/internal/project/registry/ProjectRegistryManager.java +--- m2e-core-8328691915d0e67544c97597b0ea02d559f0f4ea-new/org.eclipse.m2e.core/src/org/eclipse/m2e/core/internal/project/registry/ProjectRegistryManager.java 2020-03-05 13:08:51.000000000 +0000 ++++ m2e-core-c5392da6bab9893bcbf5b43f651abe48d5819bea-old-old/org.eclipse.m2e.core/src/org/eclipse/m2e/core/internal/project/registry/ProjectRegistryManager.java 2019-03-05 15:19:21.000000000 +0000 +@@ -27,13 +25,10 @@ + import java.util.List; + import java.util.ListIterator; + import java.util.Map; +-import java.util.Map.Entry; +-import java.util.Objects; + import java.util.Properties; + import java.util.Set; ++import java.util.concurrent.Callable; + import java.util.concurrent.ExecutionException; +-import java.util.function.Consumer; +-import java.util.stream.Collectors; + + import org.slf4j.Logger; + import org.slf4j.LoggerFactory; +@@ -42,12 +37,10 @@ + import com.google.common.cache.CacheBuilder; + import com.google.common.cache.RemovalCause; + import com.google.common.cache.RemovalListener; +-import com.google.common.collect.LinkedHashMultimap; +-import com.google.common.collect.Multimap; ++import com.google.common.cache.RemovalNotification; + + import org.eclipse.core.resources.IFile; + import org.eclipse.core.resources.IProject; +-import org.eclipse.core.resources.IResource; + import org.eclipse.core.resources.ResourcesPlugin; + import org.eclipse.core.runtime.CoreException; + import org.eclipse.core.runtime.IPath; +@@ -71,14 +64,11 @@ + import org.apache.maven.lifecycle.MavenExecutionPlan; + import org.apache.maven.model.Model; + import org.apache.maven.model.Parent; +-import org.apache.maven.model.building.ModelProblem; +-import org.apache.maven.model.building.ModelProblem.Severity; + import org.apache.maven.plugin.ExtensionRealmCache; + import org.apache.maven.plugin.MojoExecution; + import org.apache.maven.plugin.PluginArtifactsCache; + import org.apache.maven.plugin.PluginRealmCache; + import org.apache.maven.project.MavenProject; +-import org.apache.maven.project.ProjectBuildingException; + import org.apache.maven.project.ProjectBuildingRequest; + import org.apache.maven.project.ProjectRealmCache; + import org.apache.maven.project.artifact.MavenMetadataCache; +@@ -164,11 +154,6 @@ + + private final Cache mavenProjectCache; + +- /** +- * @noreference For tests only +- */ +- Consumer> addContextProjectListener; +- + public ProjectRegistryManager(MavenImpl maven, File stateLocationDir, boolean readState, + IMavenMarkerManager mavenMarkerManager) { + this.markerManager = mavenMarkerManager; +@@ -204,10 +189,9 @@ + MavenProjectFacade projectFacade = projectRegistry.getProjectFacade(pom); + if(projectFacade == null && load) { + ResolverConfiguration configuration = ResolverConfigurationIO.readResolverConfiguration(pom.getProject()); +- MavenExecutionResult executionResult = readProjectsWithDependencies(projectRegistry, +- Collections.singletonList(pom), configuration, monitor).values().iterator().next(); ++ MavenExecutionResult executionResult = readProjectWithDependencies(projectRegistry, pom, configuration, monitor); + MavenProject mavenProject = executionResult.getProject(); +- if(mavenProject != null && mavenProject.getArtifact() != null) { ++ if(mavenProject != null) { + projectFacade = new MavenProjectFacade(this, pom, mavenProject, configuration); + } else { + List exceptions = executionResult.getExceptions(); +@@ -333,26 +317,30 @@ + // safety net -- do not force refresh of the same installed/resolved artifact more than once + final Set installedArtifacts = new HashSet(); + +- ILocalRepositoryListener listener = (repositoryBasedir, baseArtifact, artifact, artifactFile) -> { +- if(artifactFile == null) { +- // resolution error +- return; +- } +- // TODO remove=false? +- Set refresh = new LinkedHashSet(); +- if(installedArtifacts.add(artifact)) { +- refresh.addAll(newState.getVersionedDependents(MavenCapability.createMavenParent(artifact), true)); +- refresh.addAll(newState.getVersionedDependents(MavenCapability.createMavenArtifact(artifact), true)); +- refresh.addAll(newState.getVersionedDependents(MavenCapability.createMavenArtifactImport(artifact), true)); +- } +- if(installedArtifacts.add(baseArtifact)) { +- refresh.addAll(newState.getVersionedDependents(MavenCapability.createMavenParent(baseArtifact), true)); +- refresh.addAll(newState.getVersionedDependents(MavenCapability.createMavenArtifact(baseArtifact), true)); +- refresh.addAll(newState.getVersionedDependents(MavenCapability.createMavenArtifactImport(baseArtifact), true)); +- } +- if(!refresh.isEmpty()) { +- log.debug("Automatic refresh. artifact={}/{}. projects={}", new Object[] {baseArtifact, artifact, refresh}); +- context.forcePomFiles(refresh); ++ ILocalRepositoryListener listener = new ILocalRepositoryListener() { ++ public void artifactInstalled(File repositoryBasedir, ArtifactKey baseArtifact, ArtifactKey artifact, ++ File artifactFile) { ++ if(artifactFile == null) { ++ // resolution error ++ return; ++ } ++ // TODO remove=false? ++ Set refresh = new LinkedHashSet(); ++ if(installedArtifacts.add(artifact)) { ++ refresh.addAll(newState.getVersionedDependents(MavenCapability.createMavenParent(artifact), true)); ++ refresh.addAll(newState.getVersionedDependents(MavenCapability.createMavenArtifact(artifact), true)); ++ refresh.addAll(newState.getVersionedDependents(MavenCapability.createMavenArtifactImport(artifact), true)); ++ } ++ if(installedArtifacts.add(baseArtifact)) { ++ refresh.addAll(newState.getVersionedDependents(MavenCapability.createMavenParent(baseArtifact), true)); ++ refresh.addAll(newState.getVersionedDependents(MavenCapability.createMavenArtifact(baseArtifact), true)); ++ refresh ++ .addAll(newState.getVersionedDependents(MavenCapability.createMavenArtifactImport(baseArtifact), true)); ++ } ++ if(!refresh.isEmpty()) { ++ log.debug("Automatic refresh. artifact={}/{}. projects={}", new Object[] {baseArtifact, artifact, refresh}); ++ context.forcePomFiles(refresh); ++ } + } + }; + +@@ -368,111 +356,96 @@ + + private void refresh(final MutableProjectRegistry newState, final DependencyResolutionContext context, + IProgressMonitor monitor) throws CoreException { +- Set allProcessedPoms = new HashSet<>(); +- Set allNewFacades = new HashSet<>(); ++ Set secondPhaseBacklog = new LinkedHashSet(); + +- final Map> originalCapabilities = new HashMap<>(); +- final Map> originalRequirements = new HashMap<>(); ++ final Map> originalCapabilities = new HashMap>(); ++ final Map> originalRequirements = new HashMap>(); + + // phase 1: build projects without dependencies and populate workspace with known projects +- while(!context.isEmpty()) { // context may be augmented, so we need to keep processing +- List toReadPomFiles = new ArrayList<>(); +- while(!context.isEmpty()) { // Group build of all current context +- if(monitor.isCanceled()) { +- throw new OperationCanceledException(); +- } ++ while(!context.isEmpty()) { ++ if(monitor.isCanceled()) { ++ throw new OperationCanceledException(); ++ } + +- if(newState.isStale() || (syncRefreshThread != null && syncRefreshThread != Thread.currentThread())) { +- throw new StaleMutableProjectRegistryException(); +- } ++ if(newState.isStale() || (syncRefreshThread != null && syncRefreshThread != Thread.currentThread())) { ++ throw new StaleMutableProjectRegistryException(); ++ } + +- IFile pom = context.pop(); +- if(allNewFacades.contains(pom)) { +- // pom was already in context and successfully read +- continue; +- } +- allProcessedPoms.add(pom); ++ IFile pom = context.pop(); + +- monitor.subTask(NLS.bind(Messages.ProjectRegistryManager_task_project, pom.getProject().getName())); +- MavenProjectFacade oldFacade = newState.getProjectFacade(pom); ++ monitor.subTask(NLS.bind(Messages.ProjectRegistryManager_task_project, pom.getProject().getName())); ++ MavenProjectFacade oldFacade = newState.getProjectFacade(pom); + +- context.forcePomFiles(flushCaches(newState, pom, oldFacade, isForceDependencyUpdate())); +- if(oldFacade != null) { +- putMavenProject(oldFacade, null); // maintain maven project cache +- } +- if(pom.isAccessible() && pom.getProject().hasNature(IMavenConstants.NATURE_ID)) { +- toReadPomFiles.add(pom); +- if(oldFacade != null) { +- // refresh old child modules +- MavenCapability mavenParentCapability = MavenCapability.createMavenParent(oldFacade.getArtifactKey()); +- context.forcePomFiles(newState.getVersionedDependents(mavenParentCapability, true)); +- +- // refresh projects that import dependencyManagement from this one +- MavenCapability mavenArtifactImportCapability = MavenCapability +- .createMavenArtifactImport(oldFacade.getArtifactKey()); +- context.forcePomFiles(newState.getVersionedDependents(mavenArtifactImportCapability, true)); +- } +- } else { +- newState.setProject(pom, null); // discard closed/deleted pom in workspace +- // refresh children of deleted/closed parent +- if(oldFacade != null) { +- MavenCapability mavenParentCapability = MavenCapability.createMavenParent(oldFacade.getArtifactKey()); +- context.forcePomFiles(newState.getDependents(mavenParentCapability, true)); +- +- MavenCapability mavenArtifactImportCapability = MavenCapability +- .createMavenArtifactImport(oldFacade.getArtifactKey()); +- context.forcePomFiles(newState.getVersionedDependents(mavenArtifactImportCapability, true)); +- } +- } ++ context.forcePomFiles(flushCaches(newState, pom, oldFacade, isForceDependencyUpdate())); ++ if(oldFacade != null) { ++ putMavenProject(oldFacade, null); // maintain maven project cache + } +- Map newFacades = readMavenProjectFacades(toReadPomFiles, newState, monitor); +- for(Entry entry : newFacades.entrySet()) { +- IFile pom = entry.getKey(); +- MavenProjectFacade newFacade = entry.getValue(); +- newState.setProject(pom, newFacade); +- if(newFacade != null) { +- // refresh new child modules +- MavenCapability mavenParentCapability = MavenCapability.createMavenParent(newFacade.getArtifactKey()); ++ MavenProjectFacade newFacade = null; ++ if(pom.isAccessible() && pom.getProject().hasNature(IMavenConstants.NATURE_ID)) { ++ if(oldFacade != null) { ++ // refresh old child modules ++ MavenCapability mavenParentCapability = MavenCapability.createMavenParent(oldFacade.getArtifactKey()); + context.forcePomFiles(newState.getVersionedDependents(mavenParentCapability, true)); + + // refresh projects that import dependencyManagement from this one + MavenCapability mavenArtifactImportCapability = MavenCapability +- .createMavenArtifactImport(newFacade.getArtifactKey()); ++ .createMavenArtifactImport(oldFacade.getArtifactKey()); + context.forcePomFiles(newState.getVersionedDependents(mavenArtifactImportCapability, true)); ++ } + +- Set capabilities = new LinkedHashSet(); +- capabilities.add(mavenParentCapability); +- capabilities.add(MavenCapability.createMavenArtifact(newFacade.getArtifactKey())); +- Set oldCapabilities = newState.setCapabilities(pom, capabilities); +- if(!originalCapabilities.containsKey(pom)) { +- originalCapabilities.put(pom, oldCapabilities); +- } ++ newFacade = readMavenProjectFacade(pom, newState, monitor); ++ } else { ++ // refresh children of deleted/closed parent ++ if(oldFacade != null) { ++ MavenCapability mavenParentCapability = MavenCapability.createMavenParent(oldFacade.getArtifactKey()); ++ context.forcePomFiles(newState.getDependents(mavenParentCapability, true)); + +- MavenProject mavenProject = getMavenProject(newFacade); +- Set requirements = new LinkedHashSet(); +- DefaultMavenDependencyResolver.addProjectStructureRequirements(requirements, mavenProject); +- Set oldRequirements = newState.setRequirements(pom, requirements); +- if(!originalRequirements.containsKey(pom)) { +- originalRequirements.put(pom, oldRequirements); +- } ++ MavenCapability mavenArtifactImportCapability = MavenCapability ++ .createMavenArtifactImport(oldFacade.getArtifactKey()); ++ context.forcePomFiles(newState.getVersionedDependents(mavenArtifactImportCapability, true)); + } + } +- allNewFacades.addAll(newFacades.keySet()); +- List erroneousPoms = new ArrayList(toReadPomFiles); +- erroneousPoms.removeAll(newFacades.keySet()); +- erroneousPoms.forEach(pom -> newState.setProject(pom, null)); +- if(!newFacades.isEmpty()) { // progress did happen +- // push files that could't be read back into context for a second pass. +- // This can help if some read files are parent of other ones in the same +- // request -> the child wouldn't be read immediately, but would be in a +- // 2nd pass once parent was read. +- context.forcePomFiles(new HashSet(erroneousPoms)); ++ ++ newState.setProject(pom, newFacade); ++ ++ if(newFacade != null) { ++ // refresh new child modules ++ MavenCapability mavenParentCapability = MavenCapability.createMavenParent(newFacade.getArtifactKey()); ++ context.forcePomFiles(newState.getVersionedDependents(mavenParentCapability, true)); ++ ++ // refresh projects that import dependencyManagement from this one ++ MavenCapability mavenArtifactImportCapability = MavenCapability ++ .createMavenArtifactImport(newFacade.getArtifactKey()); ++ context.forcePomFiles(newState.getVersionedDependents(mavenArtifactImportCapability, true)); ++ ++ Set capabilities = new LinkedHashSet(); ++ capabilities.add(mavenParentCapability); ++ capabilities.add(MavenCapability.createMavenArtifact(newFacade.getArtifactKey())); ++ Set oldCapabilities = newState.setCapabilities(pom, capabilities); ++ if(!originalCapabilities.containsKey(pom)) { ++ originalCapabilities.put(pom, oldCapabilities); ++ } ++ ++ MavenProject mavenProject = getMavenProject(newFacade); ++ Set requirements = new LinkedHashSet(); ++ DefaultMavenDependencyResolver.addProjectStructureRequirements(requirements, mavenProject); ++ Set oldRequirements = newState.setRequirements(pom, requirements); ++ if(!originalRequirements.containsKey(pom)) { ++ originalRequirements.put(pom, oldRequirements); ++ } ++ + } ++ ++ // at this point project facade and project capabilities/requirements are inconsistent in the state ++ // this will be reconciled during the second phase ++ ++ secondPhaseBacklog.add(pom); + } + +- context.forcePomFiles(allProcessedPoms); ++ context.forcePomFiles(secondPhaseBacklog); + + // phase 2: resolve project dependencies ++ Set secondPhaseProcessed = new HashSet(); + while(!context.isEmpty()) { + if(monitor.isCanceled()) { + throw new OperationCanceledException(); +@@ -484,15 +457,20 @@ + + final IFile pom = context.pop(); + ++ if(!secondPhaseProcessed.add(pom)) { ++ // because workspace contents is fully known at this point, each project needs to be resolved at most once ++ continue; ++ } ++ + MavenProjectFacade newFacade = null; + if(pom.isAccessible() && pom.getProject().hasNature(IMavenConstants.NATURE_ID)) { + newFacade = newState.getProjectFacade(pom); + } + if(newFacade != null) { + MavenProject mavenProject = getMavenProject(newFacade); +- if(!allProcessedPoms.contains(newFacade.getPom())) { ++ if(mavenProject == null) { + // facade from workspace state that has not been refreshed yet +- newFacade = readMavenProjectFacades(Collections.singletonList(pom), newState, monitor).get(pom); ++ newFacade = readMavenProjectFacade(pom, newState, monitor); + } else { + // recreate facade instance to trigger project changed event + // this is only necessary for facades that are refreshed because their dependencies changed +@@ -505,12 +483,12 @@ + + if(newFacade != null) { + final MavenProjectFacade _newFacade = newFacade; ++ final MavenProject mavenProject = getMavenProject(newFacade); + final ResolverConfiguration resolverConfiguration = _newFacade.getResolverConfiguration(); +- createExecutionContext(newState, pom, resolverConfiguration).execute(getMavenProject(newFacade), +- (executionContext, pm) -> { +- refreshPhase2(newState, context, originalCapabilities, originalRequirements, pom, _newFacade, pm); +- return null; +- }, monitor); ++ createExecutionContext(newState, pom, resolverConfiguration).execute(mavenProject, (executionContext, pm) -> { ++ refreshPhase2(newState, context, originalCapabilities, originalRequirements, pom, _newFacade, pm); ++ return null; ++ }, monitor); + } else { + refreshPhase2(newState, context, originalCapabilities, originalRequirements, pom, newFacade, monitor); + } +@@ -706,58 +684,36 @@ + return new DefaultMavenDependencyResolver(this, markerManager); + } + +- private Map readMavenProjectFacades(final Collection poms, +- final MutableProjectRegistry state, final IProgressMonitor monitor) +- throws CoreException { +- for(IFile pom : poms) { +- markerManager.deleteMarkers(pom, IMavenConstants.MARKER_POM_LOADING_ID); +- } ++ private MavenProjectFacade readMavenProjectFacade(final IFile pom, final MutableProjectRegistry state, ++ final IProgressMonitor monitor) throws CoreException { ++ markerManager.deleteMarkers(pom, IMavenConstants.MARKER_POM_LOADING_ID); ++ ++ final ResolverConfiguration resolverConfiguration = ResolverConfigurationIO ++ .readResolverConfiguration(pom.getProject()); ++ ++ return execute(state, pom, resolverConfiguration, (executionContext, pm) -> { ++ MavenProject mavenProject = null; ++ MavenExecutionResult mavenResult = null; ++ if(pom.isAccessible()) { ++ mavenResult = getMaven().readMavenProject(pom.getLocation().toFile(), ++ executionContext.newProjectBuildingRequest()); ++ mavenProject = mavenResult.getProject(); ++ } + +- final Map resolverConfigurations = new HashMap<>(poms.size(), 1.f); +- final Multimap groupsToImport = LinkedHashMultimap.create(); +- for(IFile pom : poms) { +- if(monitor.isCanceled()) { +- return null; +- } +- ResolverConfiguration resolverConfiguration = ResolverConfigurationIO.readResolverConfiguration(pom.getProject()); +- resolverConfigurations.put(pom, resolverConfiguration); +- groupsToImport.put(resolverConfiguration, pom); +- } +- +- Map result = new HashMap<>(poms.size(), 1.f); +- SubMonitor subMonitor = SubMonitor.convert(monitor, poms.size()); +- for(Entry> entry : groupsToImport.asMap().entrySet()) { +- ResolverConfiguration resolverConfiguration = entry.getKey(); +- Collection pomFiles = entry.getValue(); +- result.putAll(execute(state, poms.size() == 1 ? pomFiles.iterator().next() : null, resolverConfiguration, +- (executionContext, pm) -> { +- Map mavenResults = getMaven().readMavenProjects(pomFiles.stream() +- .filter(IFile::isAccessible).map(pom -> pom.getLocation().toFile()).collect(Collectors.toList()), +- executionContext.newProjectBuildingRequest()); +- +- Map facades = new HashMap<>(mavenResults.size(), 1.f); +- for (IFile pom : pomFiles) { +- if (!pom.isAccessible()) { +- continue; +- } +- MavenExecutionResult mavenResult = mavenResults.get(pom.getLocation().toFile()); +- MavenProject mavenProject = mavenResult.getProject(); +- MarkerUtils.addEditorHintMarkers(markerManager, pom, mavenProject, +- IMavenConstants.MARKER_POM_LOADING_ID); +- markerManager.addMarkers(pom, IMavenConstants.MARKER_POM_LOADING_ID, mavenResult); +- if(mavenProject != null && mavenProject.getArtifact() != null) { +- MavenProjectFacade mavenProjectFacade = new MavenProjectFacade(ProjectRegistryManager.this, pom, mavenProject, +- resolverConfiguration); +- putMavenProject(mavenProjectFacade, mavenProject); // maintain maven project cache +- facades.put(pom, mavenProjectFacade); +- } +- } ++ MarkerUtils.addEditorHintMarkers(markerManager, pom, mavenProject, IMavenConstants.MARKER_POM_LOADING_ID); ++ markerManager.addMarkers(pom, IMavenConstants.MARKER_POM_LOADING_ID, mavenResult); ++ if(mavenProject == null) { ++ return null; ++ } + +- return facades; +- }, subMonitor.split(pomFiles.size()) +- )); +- } +- return result; ++ // create and return new project facade ++ MavenProjectFacade mavenProjectFacade = new MavenProjectFacade(ProjectRegistryManager.this, pom, mavenProject, ++ resolverConfiguration); ++ ++ putMavenProject(mavenProjectFacade, mavenProject); // maintain maven project cache ++ ++ return mavenProjectFacade; ++ }, monitor); + } + + /*package*/Map> calculateExecutionPlans(IFile pom, MavenProject mavenProject, +@@ -829,14 +785,9 @@ + + MavenProject readProjectWithDependencies(IFile pomFile, ResolverConfiguration resolverConfiguration, + IProgressMonitor monitor) throws CoreException { +- Map results = readProjectsWithDependencies(projectRegistry, +- Collections.singletonList(pomFile), resolverConfiguration, monitor); +- if(results.size() != 1) { +- throw new IllegalStateException("Results should contain one entry."); +- } +- MavenExecutionResult result = results.values().iterator().next(); ++ MavenExecutionResult result = readProjectWithDependencies(projectRegistry, pomFile, resolverConfiguration, monitor); + MavenProject mavenProject = result.getProject(); +- if(mavenProject != null && !hasError(result)) { ++ if(mavenProject != null) { + return mavenProject; + } + MultiStatus status = new MultiStatus(IMavenConstants.PLUGIN_ID, 0, Messages.MavenProjectFacade_error, null); +@@ -847,34 +798,21 @@ + throw new CoreException(status); + } + +- private static boolean hasError(MavenExecutionResult mavenExecutionResult) { +- return mavenExecutionResult.getExceptions().stream().anyMatch(ex -> !(ex instanceof ProjectBuildingException)) +- || mavenExecutionResult.getExceptions().stream()// +- .map(ProjectBuildingException.class::cast)// +- .flatMap(ex -> ex.getResults().stream())// +- .flatMap(result -> result.getProblems().stream())// +- .map(ModelProblem::getSeverity)// +- .anyMatch(severity -> severity != Severity.WARNING); +- } ++ private MavenExecutionResult readProjectWithDependencies(IProjectRegistry state, final IFile pomFile, ++ ResolverConfiguration resolverConfiguration, final IProgressMonitor monitor) { + +- Map readProjectsWithDependencies(IProjectRegistry state, Collection pomFiles, +- ResolverConfiguration resolverConfiguration, IProgressMonitor monitor) { + try { +- return execute(state, pomFiles.size() == 1 ? pomFiles.iterator().next() : null, resolverConfiguration, +- (context, aMonitor) -> { +- ProjectBuildingRequest configuration = context.newProjectBuildingRequest(); +- configuration.setResolveDependencies(true); +- return getMaven().readMavenProjects( +- pomFiles.stream().map(file -> file.getLocation().toFile()).collect(Collectors.toList()), +- configuration); ++ return execute(state, pomFile, resolverConfiguration, (context, pm) -> { ++ ProjectBuildingRequest configuration = context.newProjectBuildingRequest(); ++ configuration.setResolveDependencies(true); ++ return getMaven().readMavenProject(pomFile.getLocation().toFile(), configuration); + }, monitor); + } catch(CoreException ex) { +- MavenExecutionResult result = new DefaultMavenExecutionResult(); ++ DefaultMavenExecutionResult result = new DefaultMavenExecutionResult(); + result.addException(ex); +- return pomFiles.stream().filter(IResource::isAccessible).map(IResource::getLocation).filter(Objects::nonNull) +- .map(IPath::toFile).collect(HashMap::new, (map, pomFile) -> map.put(pomFile, result), +- (container, toFold) -> container.putAll(toFold)); ++ return result; + } ++ + } + + public IMavenProjectFacade[] getProjects() { +@@ -1098,9 +1037,6 @@ + Map mavenProjects = getContextProjects(); + if(mavenProject != null) { + mavenProjects.put(facade, mavenProject); +- if(this.addContextProjectListener != null) { +- this.addContextProjectListener.accept(mavenProjects); +- } + } else { + mavenProjects.remove(facade); + synchronized(legacyMavenProjects) { diff --git a/eclipse-m2e-core.spec b/eclipse-m2e-core.spec index 9d9d70f..12b983d 100644 --- a/eclipse-m2e-core.spec +++ b/eclipse-m2e-core.spec @@ -2,7 +2,7 @@ Name: eclipse-m2e-core Version: 1.15.0 -Release: 2%{?dist} +Release: 3%{?dist} Summary: Maven integration for Eclipse # Most of components are under EPL, but some of them are licensed under @@ -28,6 +28,8 @@ Patch3: 0004-Remove-mandatory-attirbutes-from-OSGi-manifests-whic.patch # Use latest version of maven-archetypes Patch4: 0005-Port-to-latest-version-of-maven-archetypes.patch +Patch1000: core.patch + BuildArch: noarch # Upstream Eclipse no longer supports non-64bit arches @@ -320,6 +322,8 @@ sed -i -e '/org.slf4j/s|^\(.*\)|\1,org.apache.lucene.analysis,org.apache.lucene. sed -i -e 's/DefaultProjectBuilder\.DISABLE_GLOBAL_MODEL_CACHE_SYSTEM_PROPERTY/"maven.defaultProjectBuilder.disableGlobalModelCache"/' \ org.eclipse.m2e.core/src/org/eclipse/m2e/core/internal/MavenPluginActivator.java +%patch1000 -p1 + %build # Building m2e is a two step process. See upstream documentation: # http://wiki.eclipse.org/M2E_Development_Environment#Building_m2e_on_command_line @@ -363,6 +367,9 @@ xmvn-subst -s $(find %{buildroot}%{_datadir}/eclipse/droplets/m2e-core -name jar %license LICENSE-2.0.txt %changelog +* Wed Apr 01 2020 Mat Booth - 1.15.0-3 +- Add patch to fix NoClassDefFoundErrors + * Wed Mar 25 2020 Mat Booth - 1.15.0-2 - Improve archetype patch