1 package org.apache.maven.shared.transfer.dependencies.resolve.internal;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.util.Collection;
23 import java.util.List;
24
25 import org.apache.maven.RepositoryUtils;
26 import org.apache.maven.artifact.handler.manager.ArtifactHandlerManager;
27 import org.apache.maven.model.Dependency;
28 import org.apache.maven.model.Model;
29 import org.apache.maven.project.ProjectBuildingRequest;
30 import org.apache.maven.shared.artifact.filter.resolve.TransformableFilter;
31 import org.apache.maven.shared.transfer.artifact.resolve.ArtifactResult;
32 import org.apache.maven.shared.transfer.dependencies.DependableCoordinate;
33 import org.apache.maven.shared.transfer.dependencies.resolve.DependencyResolver;
34 import org.apache.maven.shared.transfer.dependencies.resolve.DependencyResolverException;
35 import org.codehaus.plexus.PlexusConstants;
36 import org.codehaus.plexus.PlexusContainer;
37 import org.codehaus.plexus.component.annotations.Component;
38 import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
39 import org.codehaus.plexus.context.Context;
40 import org.codehaus.plexus.context.ContextException;
41 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable;
42
43
44
45
46 @Component( role = DependencyResolver.class, hint = "default" )
47 class DefaultDependencyResolver
48 implements DependencyResolver, Contextualizable
49 {
50 private PlexusContainer container;
51
52 @Override
53 public Iterable<ArtifactResult> resolveDependencies( ProjectBuildingRequest buildingRequest,
54 Collection<Dependency> coordinates,
55 Collection<Dependency> managedDependencies,
56 TransformableFilter filter )
57 throws DependencyResolverException
58 {
59 validateBuildingRequest( buildingRequest );
60
61 try
62 {
63 return getMavenDependencyResolver( buildingRequest ).resolveDependencies( coordinates, managedDependencies,
64 filter );
65 }
66 catch ( ComponentLookupException e )
67 {
68 throw new DependencyResolverException( e.getMessage(), e );
69 }
70 }
71
72 @Override
73 public Iterable<ArtifactResult> resolveDependencies( ProjectBuildingRequest buildingRequest,
74 DependableCoordinate coordinate, TransformableFilter filter )
75 throws DependencyResolverException
76 {
77 validateParameters( buildingRequest, coordinate, filter );
78 try
79 {
80 return getMavenDependencyResolver( buildingRequest ).resolveDependencies( coordinate, filter );
81 }
82 catch ( ComponentLookupException e )
83 {
84 throw new DependencyResolverException( e.getMessage(), e );
85 }
86 }
87
88 @Override
89 public Iterable<ArtifactResult> resolveDependencies( ProjectBuildingRequest buildingRequest, Model model,
90 TransformableFilter filter )
91 throws DependencyResolverException
92 {
93 validateParameters( buildingRequest, model, filter );
94 try
95 {
96 return getMavenDependencyResolver( buildingRequest ).resolveDependencies( model, filter );
97 }
98 catch ( ComponentLookupException e )
99 {
100 throw new DependencyResolverException( e.getMessage(), e );
101 }
102 }
103
104
105
106
107 private boolean isMaven31()
108 {
109 return canFindCoreClass( "org.eclipse.aether.artifact.Artifact" );
110 }
111
112 private boolean canFindCoreClass( String className )
113 {
114 try
115 {
116 Thread.currentThread().getContextClassLoader().loadClass( className );
117
118 return true;
119 }
120 catch ( ClassNotFoundException e )
121 {
122 return false;
123 }
124 }
125
126
127
128
129
130
131
132 public void contextualize( Context context )
133 throws ContextException
134 {
135 container = (PlexusContainer) context.get( PlexusConstants.PLEXUS_KEY );
136 }
137
138 private void validateParameters( ProjectBuildingRequest buildingRequest, DependableCoordinate coordinate,
139 TransformableFilter filter )
140 {
141 validateBuildingRequest( buildingRequest );
142 if ( coordinate == null )
143 {
144 throw new IllegalArgumentException( "The parameter coordinate is not allowed to be null." );
145 }
146 }
147
148 private void validateParameters( ProjectBuildingRequest buildingRequest, Model model,
149 TransformableFilter filter )
150 {
151 validateBuildingRequest( buildingRequest );
152 if ( model == null )
153 {
154 throw new IllegalArgumentException( "The parameter model is not allowed to be null." );
155 }
156
157 }
158
159 private MavenDependencyResolver getMavenDependencyResolver( ProjectBuildingRequest buildingRequest )
160 throws ComponentLookupException, DependencyResolverException
161 {
162 ArtifactHandlerManager artifactHandlerManager = container.lookup( ArtifactHandlerManager.class );
163
164 if ( isMaven31() )
165 {
166 org.eclipse.aether.RepositorySystem m31RepositorySystem =
167 container.lookup( org.eclipse.aether.RepositorySystem.class );
168
169 org.eclipse.aether.RepositorySystemSession session =
170 (org.eclipse.aether.RepositorySystemSession) Invoker.invoke( buildingRequest, "getRepositorySession" );
171
172 List<org.eclipse.aether.repository.RemoteRepository> aetherRepositories =
173 (List<org.eclipse.aether.repository.RemoteRepository>) Invoker.invoke( RepositoryUtils.class,
174 "toRepos",
175 List.class,
176 buildingRequest.getRemoteRepositories() );
177
178 return new Maven31DependencyResolver( m31RepositorySystem, artifactHandlerManager, session,
179 aetherRepositories );
180 }
181 else
182 {
183 org.sonatype.aether.RepositorySystem m30RepositorySystem =
184 container.lookup( org.sonatype.aether.RepositorySystem.class );
185
186 org.sonatype.aether.RepositorySystemSession session =
187 (org.sonatype.aether.RepositorySystemSession) Invoker.invoke( buildingRequest, "getRepositorySession" );
188
189 List<org.sonatype.aether.repository.RemoteRepository> aetherRepositories =
190 (List<org.sonatype.aether.repository.RemoteRepository>) Invoker.invoke( RepositoryUtils.class,
191 "toRepos",
192 List.class,
193 buildingRequest.getRemoteRepositories() );
194
195 return new Maven30DependencyResolver( m30RepositorySystem, artifactHandlerManager, session,
196 aetherRepositories );
197
198 }
199 }
200
201 private void validateBuildingRequest( ProjectBuildingRequest buildingRequest )
202 {
203 if ( buildingRequest == null )
204 {
205 throw new IllegalArgumentException( "The parameter buildingRequest is not allowed to be null." );
206 }
207 }
208
209 }