1 package org.apache.maven.report.projectinfo.dependencies;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import org.apache.maven.artifact.Artifact;
23 import org.apache.maven.artifact.ArtifactUtils;
24 import org.apache.maven.artifact.factory.ArtifactFactory;
25 import org.apache.maven.artifact.manager.WagonConfigurationException;
26 import org.apache.maven.artifact.manager.WagonManager;
27 import org.apache.maven.artifact.metadata.ArtifactMetadata;
28 import org.apache.maven.artifact.repository.ArtifactRepository;
29 import org.apache.maven.artifact.repository.metadata.Metadata;
30 import org.apache.maven.artifact.repository.metadata.RepositoryMetadataManager;
31 import org.apache.maven.artifact.repository.metadata.RepositoryMetadataResolutionException;
32 import org.apache.maven.artifact.repository.metadata.SnapshotArtifactRepositoryMetadata;
33 import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
34 import org.apache.maven.artifact.resolver.ArtifactResolutionException;
35 import org.apache.maven.artifact.resolver.ArtifactResolver;
36 import org.apache.maven.plugin.logging.Log;
37 import org.apache.maven.project.MavenProject;
38 import org.apache.maven.project.MavenProjectBuilder;
39 import org.apache.maven.project.ProjectBuildingException;
40 import org.apache.maven.settings.Proxy;
41 import org.apache.maven.settings.Settings;
42 import org.apache.maven.wagon.ConnectionException;
43 import org.apache.maven.wagon.TransferFailedException;
44 import org.apache.maven.wagon.UnsupportedProtocolException;
45 import org.apache.maven.wagon.Wagon;
46 import org.apache.maven.wagon.authentication.AuthenticationException;
47 import org.apache.maven.wagon.authentication.AuthenticationInfo;
48 import org.apache.maven.wagon.authorization.AuthorizationException;
49 import org.apache.maven.wagon.observers.Debug;
50 import org.apache.maven.wagon.proxy.ProxyInfo;
51 import org.apache.maven.wagon.repository.Repository;
52 import org.codehaus.plexus.logging.Logger;
53 import org.codehaus.plexus.logging.LoggerManager;
54 import org.codehaus.plexus.util.StringUtils;
55
56 import java.util.ArrayList;
57 import java.util.Iterator;
58 import java.util.List;
59
60
61
62
63
64
65
66 public class RepositoryUtils
67 {
68 private final Log log;
69
70 private final LoggerManager loggerManager;
71
72 private final WagonManager wagonManager;
73
74 private final Settings settings;
75
76 private final MavenProjectBuilder mavenProjectBuilder;
77
78 private final ArtifactFactory factory;
79
80 private final List remoteRepositories;
81
82 private final List pluginRepositories;
83
84 private final ArtifactResolver resolver;
85
86 private final ArtifactRepository localRepository;
87
88 private final RepositoryMetadataManager repositoryMetadataManager;
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103 public RepositoryUtils( Log log, LoggerManager loggerManager, WagonManager wagonManager, Settings settings,
104 MavenProjectBuilder mavenProjectBuilder, ArtifactFactory factory,
105 ArtifactResolver resolver, List remoteRepositories, List pluginRepositories,
106 ArtifactRepository localRepository, RepositoryMetadataManager repositoryMetadataManager )
107 {
108 this.log = log;
109 this.loggerManager = loggerManager;
110 this.wagonManager = wagonManager;
111 this.settings = settings;
112 this.mavenProjectBuilder = mavenProjectBuilder;
113 this.factory = factory;
114 this.resolver = resolver;
115 this.remoteRepositories = remoteRepositories;
116 this.pluginRepositories = pluginRepositories;
117 this.localRepository = localRepository;
118 this.repositoryMetadataManager = repositoryMetadataManager;
119 }
120
121
122
123
124 public ArtifactRepository getLocalRepository()
125 {
126 return localRepository;
127 }
128
129
130
131
132 public List getRemoteArtifactRepositories()
133 {
134 return remoteRepositories;
135 }
136
137
138
139
140 public List getPluginArtifactRepositories()
141 {
142 return pluginRepositories;
143 }
144
145
146
147
148
149
150
151 public void resolve( Artifact artifact )
152 throws ArtifactResolutionException, ArtifactNotFoundException
153 {
154 List repos = new ArrayList();
155 repos.addAll( pluginRepositories );
156 repos.addAll( remoteRepositories );
157
158 resolver.resolve( artifact, repos, localRepository );
159 }
160
161
162
163
164
165
166
167 public boolean dependencyExistsInRepo( ArtifactRepository repo, Artifact artifact )
168 {
169 if ( repo.isBlacklisted() )
170 {
171 if ( log.isDebugEnabled() )
172 {
173 log.debug( "The repo '" + repo.getId() + "' is black listed - Ignored it" );
174 }
175 return false;
176 }
177
178 String id = repo.getId();
179 Repository repository = new Repository( id, repo.getUrl() );
180
181 Wagon wagon;
182 try
183 {
184 wagon = wagonManager.getWagon( repository );
185 }
186 catch ( UnsupportedProtocolException e )
187 {
188 log.error( "Unsupported protocol: '" + repo.getProtocol() + "'", e );
189 return false;
190 }
191 catch ( WagonConfigurationException e )
192 {
193 log.error( "Unsupported protocol: '" + repo.getProtocol() + "'", e );
194 return false;
195 }
196
197 if ( log.isDebugEnabled() )
198 {
199 Debug debug = new Debug();
200
201 wagon.addSessionListener( debug );
202 wagon.addTransferListener( debug );
203 }
204
205 try
206 {
207 AuthenticationInfo auth = wagonManager.getAuthenticationInfo( repo.getId() );
208
209 ProxyInfo proxyInfo = getProxyInfo();
210 if ( proxyInfo != null )
211 {
212 wagon.connect( repository, auth, proxyInfo );
213 }
214 else
215 {
216 wagon.connect( repository, auth );
217 }
218
219 return wagon.resourceExists( StringUtils.replace( getDependencyUrlFromRepository( artifact, repo ),
220 repo.getUrl(), "" ) );
221 }
222 catch ( ConnectionException e )
223 {
224 if ( log.isDebugEnabled() )
225 {
226 log.error( "Unable to connect to: " + repo.getUrl(), e );
227 }
228 else
229 {
230 log.error( "Unable to connect to: " + repo.getUrl() );
231 }
232 return false;
233 }
234 catch ( AuthenticationException e )
235 {
236 if ( log.isDebugEnabled() )
237 {
238 log.error( "Unable to connect to: " + repo.getUrl(), e );
239 }
240 else
241 {
242 log.error( "Unable to connect to: " + repo.getUrl() );
243 }
244 return false;
245 }
246 catch ( TransferFailedException e )
247 {
248 if ( log.isDebugEnabled() )
249 {
250 log.error( "Unable to determine if resource " + artifact + " exists in " + repo.getUrl(), e );
251 }
252 else
253 {
254 log.error( "Unable to determine if resource " + artifact + " exists in " + repo.getUrl() );
255 }
256 return false;
257 }
258 catch ( AuthorizationException e )
259 {
260 if ( log.isDebugEnabled() )
261 {
262 log.error( "Unable to connect to: " + repo.getUrl(), e );
263 }
264 else
265 {
266 log.error( "Unable to connect to: " + repo.getUrl() );
267 }
268 return false;
269 }
270 catch ( AbstractMethodError e )
271 {
272 log.error( "Wagon " + wagon.getClass().getName() + " does not support the resourceExists method" );
273 return false;
274 }
275 finally
276 {
277 try
278 {
279 wagon.disconnect();
280 }
281 catch ( ConnectionException e )
282 {
283 if ( log.isDebugEnabled() )
284 {
285 log.error( "Error disconnecting wagon - ignored", e );
286 }
287 else
288 {
289 log.error( "Error disconnecting wagon - ignored" );
290 }
291 }
292 }
293 }
294
295
296
297
298
299
300
301
302 public MavenProject getMavenProjectFromRepository( Artifact artifact )
303 throws ProjectBuildingException
304 {
305 Artifact projectArtifact = artifact;
306
307 boolean allowStubModel = false;
308 if ( !"pom".equals( artifact.getType() ) )
309 {
310 projectArtifact = factory.createProjectArtifact( artifact.getGroupId(), artifact.getArtifactId(),
311 artifact.getVersion(), artifact.getScope() );
312 allowStubModel = true;
313 }
314
315
316 return mavenProjectBuilder.buildFromRepository( projectArtifact, remoteRepositories, localRepository,
317 allowStubModel );
318 }
319
320
321
322
323
324
325
326 public String getDependencyUrlFromRepository( Artifact artifact, ArtifactRepository repo )
327 {
328 if ( repo.isBlacklisted() )
329 {
330 return null;
331 }
332
333 Artifact copyArtifact = ArtifactUtils.copyArtifact( artifact );
334
335 if ( ( artifact.isSnapshot() && repo.getSnapshots().isEnabled() ) )
336 {
337 if ( artifact.getBaseVersion().equals( artifact.getVersion() ) )
338 {
339
340 if ( artifact.getMetadataList() == null || artifact.getMetadataList().isEmpty() )
341 {
342 try
343 {
344 resolve( artifact );
345 }
346 catch ( ArtifactResolutionException e )
347 {
348 log.error( "Artifact: " + artifact.getId() + " could not be resolved." );
349 }
350 catch ( ArtifactNotFoundException e )
351 {
352 log.error( "Artifact: " + artifact.getId() + " was not found." );
353 }
354 }
355
356 for ( Iterator it = artifact.getMetadataList().iterator(); it.hasNext(); )
357 {
358 ArtifactMetadata m = (ArtifactMetadata) it.next();
359
360 if ( m instanceof SnapshotArtifactRepositoryMetadata )
361 {
362 SnapshotArtifactRepositoryMetadata snapshotMetadata = (SnapshotArtifactRepositoryMetadata) m;
363
364
365 int oldThreshold = loggerManager.getThreshold();
366 loggerManager.setThreshold( RepositoryMetadataManager.class.getName(), Logger.LEVEL_DISABLED );
367 try
368 {
369 repositoryMetadataManager.resolveAlways( snapshotMetadata, localRepository, repo );
370 }
371 catch ( RepositoryMetadataResolutionException e )
372 {
373 loggerManager.setThreshold( RepositoryMetadataManager.class.getName(), oldThreshold );
374 if ( log.isDebugEnabled() )
375 {
376 log.error( "Unable to connect to: " + repo.getUrl(), e );
377 }
378 else
379 {
380 log.error( "Unable to connect to: " + repo.getUrl() );
381 }
382 return repo.getUrl() + "/" + repo.pathOf( copyArtifact );
383 }
384 finally
385 {
386 loggerManager.setThreshold( RepositoryMetadataManager.class.getName(), oldThreshold );
387 }
388
389 Metadata metadata = snapshotMetadata.getMetadata();
390 if ( metadata.getVersioning() == null || metadata.getVersioning().getSnapshot() == null
391 || metadata.getVersioning().getSnapshot().isLocalCopy()
392 || metadata.getVersioning().getSnapshot().getTimestamp() == null )
393 {
394 continue;
395 }
396
397
398 String version =
399 StringUtils.replace( copyArtifact.getVersion(), Artifact.SNAPSHOT_VERSION,
400 metadata.getVersioning().getSnapshot().getTimestamp() )
401 + "-" + metadata.getVersioning().getSnapshot().getBuildNumber();
402 copyArtifact.setVersion( version );
403 }
404 }
405 }
406 }
407
408 return repo.getUrl() + "/" + repo.pathOf( copyArtifact );
409 }
410
411
412
413
414
415
416
417
418
419
420
421 private ProxyInfo getProxyInfo()
422 {
423 ProxyInfo proxyInfo = null;
424 if ( settings != null && settings.getActiveProxy() != null )
425 {
426 Proxy settingsProxy = settings.getActiveProxy();
427
428 proxyInfo = new ProxyInfo();
429 proxyInfo.setHost( settingsProxy.getHost() );
430 proxyInfo.setType( settingsProxy.getProtocol() );
431 proxyInfo.setPort( settingsProxy.getPort() );
432 proxyInfo.setNonProxyHosts( settingsProxy.getNonProxyHosts() );
433 proxyInfo.setUserName( settingsProxy.getUsername() );
434 proxyInfo.setPassword( settingsProxy.getPassword() );
435 }
436
437 return proxyInfo;
438 }
439 }