001 package org.apache.maven.project;
002
003 /*
004 * Licensed to the Apache Software Foundation (ASF) under one
005 * or more contributor license agreements. See the NOTICE file
006 * distributed with this work for additional information
007 * regarding copyright ownership. The ASF licenses this file
008 * to you under the Apache License, Version 2.0 (the
009 * "License"); you may not use this file except in compliance
010 * with the License. You may obtain a copy of the License at
011 *
012 * http://www.apache.org/licenses/LICENSE-2.0
013 *
014 * Unless required by applicable law or agreed to in writing,
015 * software distributed under the License is distributed on an
016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017 * KIND, either express or implied. See the License for the
018 * specific language governing permissions and limitations
019 * under the License.
020 */
021
022 import java.io.IOException;
023 import java.util.ArrayList;
024 import java.util.Arrays;
025 import java.util.Collection;
026 import java.util.HashMap;
027 import java.util.HashSet;
028 import java.util.LinkedHashSet;
029 import java.util.List;
030 import java.util.Map;
031 import java.util.Set;
032
033 import org.apache.maven.artifact.InvalidRepositoryException;
034 import org.apache.maven.artifact.repository.ArtifactRepository;
035 import org.apache.maven.classrealm.ClassRealmManager;
036 import org.apache.maven.model.Build;
037 import org.apache.maven.model.Extension;
038 import org.apache.maven.model.Model;
039 import org.apache.maven.model.Plugin;
040 import org.apache.maven.model.Repository;
041 import org.apache.maven.plugin.ExtensionRealmCache;
042 import org.apache.maven.plugin.PluginArtifactsCache;
043 import org.apache.maven.plugin.PluginResolutionException;
044 import org.apache.maven.plugin.internal.PluginDependenciesResolver;
045 import org.apache.maven.plugin.version.DefaultPluginVersionRequest;
046 import org.apache.maven.plugin.version.PluginVersionRequest;
047 import org.apache.maven.plugin.version.PluginVersionResolutionException;
048 import org.apache.maven.plugin.version.PluginVersionResolver;
049 import org.apache.maven.repository.RepositorySystem;
050 import org.codehaus.plexus.PlexusContainer;
051 import org.codehaus.plexus.classworlds.realm.ClassRealm;
052 import org.codehaus.plexus.component.annotations.Component;
053 import org.codehaus.plexus.component.annotations.Requirement;
054 import org.codehaus.plexus.logging.Logger;
055 import org.eclipse.aether.artifact.Artifact;
056 import org.eclipse.aether.graph.DependencyFilter;
057 import org.eclipse.aether.graph.DependencyNode;
058 import org.eclipse.aether.repository.RemoteRepository;
059 import org.eclipse.aether.util.filter.ExclusionsDependencyFilter;
060 import org.eclipse.aether.util.graph.visitor.PreorderNodeListGenerator;
061
062 /**
063 * Assists the project builder. <strong>Warning:</strong> This is an internal utility class that is only public for
064 * technical reasons, it is not part of the public API. In particular, this class can be changed or deleted without
065 * prior notice.
066 *
067 * @author Benjamin Bentmann
068 */
069 @Component( role = ProjectBuildingHelper.class )
070 public class DefaultProjectBuildingHelper
071 implements ProjectBuildingHelper
072 {
073
074 @Requirement
075 private Logger logger;
076
077 @Requirement
078 private PlexusContainer container;
079
080 @Requirement
081 private ClassRealmManager classRealmManager;
082
083 @Requirement
084 private PluginArtifactsCache pluginArtifactsCache;
085
086 @Requirement
087 private ExtensionRealmCache extensionRealmCache;
088
089 @Requirement
090 private ProjectRealmCache projectRealmCache;
091
092 @Requirement
093 private RepositorySystem repositorySystem;
094
095 @Requirement
096 private PluginVersionResolver pluginVersionResolver;
097
098 @Requirement
099 private PluginDependenciesResolver pluginDependenciesResolver;
100
101 private ExtensionDescriptorBuilder extensionDescriptorBuilder = new ExtensionDescriptorBuilder();
102
103 public List<ArtifactRepository> createArtifactRepositories( List<Repository> pomRepositories,
104 List<ArtifactRepository> externalRepositories,
105 ProjectBuildingRequest request )
106 throws InvalidRepositoryException
107 {
108 List<ArtifactRepository> internalRepositories = new ArrayList<ArtifactRepository>();
109
110 for ( Repository repository : pomRepositories )
111 {
112 internalRepositories.add( repositorySystem.buildArtifactRepository( repository ) );
113 }
114
115 repositorySystem.injectMirror( request.getRepositorySession(), internalRepositories );
116
117 repositorySystem.injectProxy( request.getRepositorySession(), internalRepositories );
118
119 repositorySystem.injectAuthentication( request.getRepositorySession(), internalRepositories );
120
121 List<ArtifactRepository> dominantRepositories;
122 List<ArtifactRepository> recessiveRepositories;
123
124 if ( ProjectBuildingRequest.RepositoryMerging.REQUEST_DOMINANT.equals( request.getRepositoryMerging() ) )
125 {
126 dominantRepositories = externalRepositories;
127 recessiveRepositories = internalRepositories;
128 }
129 else
130 {
131 dominantRepositories = internalRepositories;
132 recessiveRepositories = externalRepositories;
133 }
134
135 List<ArtifactRepository> artifactRepositories = new ArrayList<ArtifactRepository>();
136 Collection<String> repoIds = new HashSet<String>();
137
138 if ( dominantRepositories != null )
139 {
140 for ( ArtifactRepository repository : dominantRepositories )
141 {
142 repoIds.add( repository.getId() );
143 artifactRepositories.add( repository );
144 }
145 }
146
147 if ( recessiveRepositories != null )
148 {
149 for ( ArtifactRepository repository : recessiveRepositories )
150 {
151 if ( repoIds.add( repository.getId() ) )
152 {
153 artifactRepositories.add( repository );
154 }
155 }
156 }
157
158 artifactRepositories = repositorySystem.getEffectiveRepositories( artifactRepositories );
159
160 return artifactRepositories;
161 }
162
163 public synchronized ProjectRealmCache.CacheRecord createProjectRealm( MavenProject project, Model model,
164 ProjectBuildingRequest request )
165 throws PluginResolutionException, PluginVersionResolutionException
166 {
167 ClassRealm projectRealm = null;
168
169 List<Plugin> extensionPlugins = new ArrayList<Plugin>();
170
171 Build build = model.getBuild();
172
173 if ( build != null )
174 {
175 for ( Extension extension : build.getExtensions() )
176 {
177 Plugin plugin = new Plugin();
178 plugin.setGroupId( extension.getGroupId() );
179 plugin.setArtifactId( extension.getArtifactId() );
180 plugin.setVersion( extension.getVersion() );
181 extensionPlugins.add( plugin );
182 }
183
184 for ( Plugin plugin : build.getPlugins() )
185 {
186 if ( plugin.isExtensions() )
187 {
188 extensionPlugins.add( plugin );
189 }
190 }
191 }
192
193 if ( extensionPlugins.isEmpty() )
194 {
195 if ( logger.isDebugEnabled() )
196 {
197 logger.debug( "Extension realms for project " + model.getId() + ": (none)" );
198 }
199
200 return new ProjectRealmCache.CacheRecord( null, null );
201 }
202
203 List<ClassRealm> extensionRealms = new ArrayList<ClassRealm>();
204
205 Map<ClassRealm, List<String>> exportedPackages = new HashMap<ClassRealm, List<String>>();
206
207 Map<ClassRealm, List<String>> exportedArtifacts = new HashMap<ClassRealm, List<String>>();
208
209 List<Artifact> publicArtifacts = new ArrayList<Artifact>();
210
211 for ( Plugin plugin : extensionPlugins )
212 {
213 if ( plugin.getVersion() == null )
214 {
215 PluginVersionRequest versionRequest =
216 new DefaultPluginVersionRequest( plugin, request.getRepositorySession(),
217 project.getRemotePluginRepositories() );
218 plugin.setVersion( pluginVersionResolver.resolve( versionRequest ).getVersion() );
219 }
220
221 List<Artifact> artifacts;
222
223 PluginArtifactsCache.Key cacheKey =
224 pluginArtifactsCache.createKey( plugin, null, project.getRemotePluginRepositories(),
225 request.getRepositorySession() );
226
227 PluginArtifactsCache.CacheRecord recordArtifacts = pluginArtifactsCache.get( cacheKey );
228
229 if ( recordArtifacts != null )
230 {
231 artifacts = recordArtifacts.artifacts;
232 }
233 else
234 {
235 try
236 {
237 artifacts = resolveExtensionArtifacts( plugin, project.getRemotePluginRepositories(), request );
238
239 recordArtifacts = pluginArtifactsCache.put( cacheKey, artifacts );
240 }
241 catch ( PluginResolutionException e )
242 {
243 pluginArtifactsCache.put( cacheKey, e );
244
245 pluginArtifactsCache.register( project, recordArtifacts );
246
247 throw e;
248 }
249 }
250
251 pluginArtifactsCache.register( project, recordArtifacts );
252
253 ClassRealm extensionRealm;
254 ExtensionDescriptor extensionDescriptor = null;
255
256 ExtensionRealmCache.CacheRecord recordRealm = extensionRealmCache.get( artifacts );
257
258 if ( recordRealm != null )
259 {
260 extensionRealm = recordRealm.realm;
261 extensionDescriptor = recordRealm.desciptor;
262 }
263 else
264 {
265 extensionRealm = classRealmManager.createExtensionRealm( plugin, artifacts );
266
267 try
268 {
269 container.discoverComponents( extensionRealm );
270 }
271 catch ( Exception e )
272 {
273 throw new IllegalStateException( "Failed to discover components in extension realm "
274 + extensionRealm.getId(), e );
275 }
276
277 Artifact extensionArtifact = artifacts.get( 0 );
278 try
279 {
280 extensionDescriptor = extensionDescriptorBuilder.build( extensionArtifact.getFile() );
281 }
282 catch ( IOException e )
283 {
284 String message = "Invalid extension descriptor for " + plugin.getId() + ": " + e.getMessage();
285 if ( logger.isDebugEnabled() )
286 {
287 logger.error( message, e );
288 }
289 else
290 {
291 logger.error( message );
292 }
293 }
294
295 recordRealm = extensionRealmCache.put( artifacts, extensionRealm, extensionDescriptor );
296 }
297
298 extensionRealmCache.register( project, recordRealm );
299
300 extensionRealms.add( extensionRealm );
301 if ( extensionDescriptor != null )
302 {
303 exportedPackages.put( extensionRealm, extensionDescriptor.getExportedPackages() );
304 exportedArtifacts.put( extensionRealm, extensionDescriptor.getExportedArtifacts() );
305 }
306
307 if ( !plugin.isExtensions() && artifacts.size() == 2 && artifacts.get( 0 ).getFile() != null
308 && "plexus-utils".equals( artifacts.get( 1 ).getArtifactId() ) )
309 {
310 /*
311 * This is purely for backward-compat with 2.x where <extensions> consisting of a single artifact where
312 * loaded into the core and hence available to plugins, in contrast to bigger extensions that were
313 * loaded into a dedicated realm which is invisible to plugins (MNG-2749).
314 */
315 publicArtifacts.add( artifacts.get( 0 ) );
316 }
317 }
318
319 if ( logger.isDebugEnabled() )
320 {
321 logger.debug( "Extension realms for project " + model.getId() + ": " + extensionRealms );
322 }
323
324 ProjectRealmCache.CacheRecord record = projectRealmCache.get( extensionRealms );
325
326 if ( record == null )
327 {
328 projectRealm = classRealmManager.createProjectRealm( model, publicArtifacts );
329
330 Set<String> exclusions = new LinkedHashSet<String>();
331
332 for ( ClassRealm extensionRealm : extensionRealms )
333 {
334 List<String> excludes = exportedArtifacts.get( extensionRealm );
335
336 if ( excludes != null )
337 {
338 exclusions.addAll( excludes );
339 }
340
341 List<String> exports = exportedPackages.get( extensionRealm );
342
343 if ( exports == null || exports.isEmpty() )
344 {
345 /*
346 * Most existing extensions don't define exported packages, i.e. no classes are to be exposed to
347 * plugins, yet the components provided by the extension (e.g. artifact handlers) must be
348 * accessible, i.e. we still must import the extension realm into the project realm.
349 */
350 exports = Arrays.asList( extensionRealm.getId() );
351 }
352
353 for ( String export : exports )
354 {
355 projectRealm.importFrom( extensionRealm, export );
356 }
357 }
358
359 DependencyFilter extensionArtifactFilter = null;
360 if ( !exclusions.isEmpty() )
361 {
362 extensionArtifactFilter = new ExclusionsDependencyFilter( exclusions );
363 }
364
365 record = projectRealmCache.put( extensionRealms, projectRealm, extensionArtifactFilter );
366 }
367
368 projectRealmCache.register( project, record );
369
370 return record;
371 }
372
373 private List<Artifact> resolveExtensionArtifacts( Plugin extensionPlugin, List<RemoteRepository> repositories,
374 ProjectBuildingRequest request )
375 throws PluginResolutionException
376 {
377 DependencyNode root =
378 pluginDependenciesResolver.resolve( extensionPlugin, null, null, repositories,
379 request.getRepositorySession() );
380
381 PreorderNodeListGenerator nlg = new PreorderNodeListGenerator();
382 root.accept( nlg );
383 return nlg.getArtifacts( false );
384 }
385
386 public void selectProjectRealm( MavenProject project )
387 {
388 ClassLoader projectRealm = project.getClassRealm();
389
390 if ( projectRealm == null )
391 {
392 projectRealm = classRealmManager.getCoreRealm();
393 }
394
395 Thread.currentThread().setContextClassLoader( projectRealm );
396 }
397
398 }