KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > maven > artifact > resolver > DefaultArtifactResolver


1 package org.apache.maven.artifact.resolver;
2
3 /*
4  * Copyright 2001-2005 The Apache Software Foundation.
5  *
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */

18
19 import org.apache.maven.artifact.Artifact;
20 import org.apache.maven.artifact.factory.ArtifactFactory;
21 import org.apache.maven.artifact.manager.WagonManager;
22 import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
23 import org.apache.maven.artifact.repository.ArtifactRepository;
24 import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
25 import org.apache.maven.artifact.transform.ArtifactTransformationManager;
26 import org.apache.maven.wagon.ResourceDoesNotExistException;
27 import org.apache.maven.wagon.TransferFailedException;
28 import org.codehaus.plexus.logging.AbstractLogEnabled;
29 import org.codehaus.plexus.util.FileUtils;
30
31 import java.io.File JavaDoc;
32 import java.io.IOException JavaDoc;
33 import java.util.ArrayList JavaDoc;
34 import java.util.Collections JavaDoc;
35 import java.util.Iterator JavaDoc;
36 import java.util.List JavaDoc;
37 import java.util.Map JavaDoc;
38 import java.util.Set JavaDoc;
39
40 public class DefaultArtifactResolver
41     extends AbstractLogEnabled
42     implements ArtifactResolver
43 {
44     // ----------------------------------------------------------------------
45
// Components
46
// ----------------------------------------------------------------------
47

48     private WagonManager wagonManager;
49
50     private ArtifactTransformationManager transformationManager;
51
52     protected ArtifactFactory artifactFactory;
53
54     private ArtifactCollector artifactCollector;
55
56     // ----------------------------------------------------------------------
57
// Implementation
58
// ----------------------------------------------------------------------
59

60     public void resolve( Artifact artifact, List JavaDoc remoteRepositories, ArtifactRepository localRepository )
61         throws ArtifactResolutionException, ArtifactNotFoundException
62     {
63         resolve( artifact, remoteRepositories, localRepository, false );
64     }
65
66     public void resolveAlways( Artifact artifact, List JavaDoc remoteRepositories, ArtifactRepository localRepository )
67         throws ArtifactResolutionException, ArtifactNotFoundException
68     {
69         resolve( artifact, remoteRepositories, localRepository, true );
70     }
71
72     private void resolve( Artifact artifact, List JavaDoc remoteRepositories, ArtifactRepository localRepository,
73                           boolean force )
74         throws ArtifactResolutionException, ArtifactNotFoundException
75     {
76         if ( artifact != null )
77         {
78             if ( Artifact.SCOPE_SYSTEM.equals( artifact.getScope() ) )
79             {
80                 File JavaDoc systemFile = artifact.getFile();
81
82                 if ( !systemFile.exists() )
83                 {
84                     throw new ArtifactNotFoundException(
85                         "System artifact: " + artifact + " not found in path: " + systemFile, artifact );
86                 }
87                 else
88                 {
89                     artifact.setResolved( true );
90                 }
91             }
92             else if ( !artifact.isResolved() )
93             {
94                 // ----------------------------------------------------------------------
95
// Check for the existence of the artifact in the specified local
96
// ArtifactRepository. If it is present then simply return as the
97
// request for resolution has been satisfied.
98
// ----------------------------------------------------------------------
99

100                 String JavaDoc localPath = localRepository.pathOf( artifact );
101
102                 artifact.setFile( new File JavaDoc( localRepository.getBasedir(), localPath ) );
103
104                 transformationManager.transformForResolve( artifact, remoteRepositories, localRepository );
105
106                 File JavaDoc destination = artifact.getFile();
107                 boolean resolved = false;
108                 if ( !destination.exists() || force )
109                 {
110                     if ( !wagonManager.isOnline() )
111                     {
112                         throw new ArtifactNotFoundException( "System is offline.", artifact );
113                     }
114
115                     try
116                     {
117                         if ( artifact.getRepository() != null )
118                         {
119                             // the transformations discovered the artifact - so use it exclusively
120
wagonManager.getArtifact( artifact, artifact.getRepository() );
121                         }
122                         else
123                         {
124                             wagonManager.getArtifact( artifact, remoteRepositories );
125                         }
126
127                         if ( !artifact.isResolved() )
128                         {
129                             throw new ArtifactResolutionException(
130                                 "Failed to resolve artifact, possibly due to a repository list that is not appropriately equipped for this artifact's metadata.",
131                                 artifact, remoteRepositories );
132                         }
133                     }
134                     catch ( ResourceDoesNotExistException e )
135                     {
136                         throw new ArtifactNotFoundException( e.getMessage(), artifact, remoteRepositories, e );
137                     }
138                     catch ( TransferFailedException e )
139                     {
140                         throw new ArtifactResolutionException( e.getMessage(), artifact, remoteRepositories, e );
141                     }
142
143                     resolved = true;
144                 }
145                 else if ( destination.exists() )
146                 {
147                     // locally resolved...no need to hit the remote repo.
148
artifact.setResolved( true );
149                 }
150
151                 if ( artifact.isSnapshot() && !artifact.getBaseVersion().equals( artifact.getVersion() ) )
152                 {
153                     String JavaDoc version = artifact.getVersion();
154                     artifact.selectVersion( artifact.getBaseVersion() );
155                     File JavaDoc copy = new File JavaDoc( localRepository.getBasedir(), localRepository.pathOf( artifact ) );
156                     if ( resolved || !copy.exists() )
157                     {
158                         // recopy file if it was reresolved, or doesn't exist.
159
try
160                         {
161                             FileUtils.copyFile( destination, copy );
162                         }
163                         catch ( IOException JavaDoc e )
164                         {
165                             throw new ArtifactResolutionException(
166                                 "Unable to copy resolved artifact for local use: " + e.getMessage(), artifact,
167                                 remoteRepositories, e );
168                         }
169                     }
170                     artifact.setFile( copy );
171                     artifact.selectVersion( version );
172                 }
173             }
174         }
175     }
176
177     public ArtifactResolutionResult resolveTransitively( Set JavaDoc artifacts, Artifact originatingArtifact,
178                                                          ArtifactRepository localRepository, List JavaDoc remoteRepositories,
179                                                          ArtifactMetadataSource source, ArtifactFilter filter )
180         throws ArtifactResolutionException, ArtifactNotFoundException
181     {
182         return resolveTransitively( artifacts, originatingArtifact, Collections.EMPTY_MAP, localRepository,
183                                     remoteRepositories, source, filter );
184
185     }
186
187     public ArtifactResolutionResult resolveTransitively( Set JavaDoc artifacts, Artifact originatingArtifact,
188                                                          Map JavaDoc managedVersions, ArtifactRepository localRepository,
189                                                          List JavaDoc remoteRepositories, ArtifactMetadataSource source )
190         throws ArtifactResolutionException, ArtifactNotFoundException
191     {
192         return resolveTransitively( artifacts, originatingArtifact, managedVersions, localRepository,
193                                     remoteRepositories, source, null );
194     }
195
196     public ArtifactResolutionResult resolveTransitively( Set JavaDoc artifacts, Artifact originatingArtifact,
197                                                          Map JavaDoc managedVersions, ArtifactRepository localRepository,
198                                                          List JavaDoc remoteRepositories, ArtifactMetadataSource source,
199                                                          ArtifactFilter filter )
200         throws ArtifactResolutionException, ArtifactNotFoundException
201     {
202         // TODO: this is simplistic
203
List JavaDoc listeners = new ArrayList JavaDoc();
204         if ( getLogger().isDebugEnabled() )
205         {
206             listeners.add( new DebugResolutionListener( getLogger() ) );
207         }
208
209         listeners.add( new WarningResolutionListener( getLogger() ) );
210
211         return resolveTransitively( artifacts, originatingArtifact, managedVersions, localRepository,
212                                     remoteRepositories, source, filter, listeners );
213
214     }
215
216     public ArtifactResolutionResult resolveTransitively( Set JavaDoc artifacts, Artifact originatingArtifact,
217                                                          Map JavaDoc managedVersions, ArtifactRepository localRepository,
218                                                          List JavaDoc remoteRepositories, ArtifactMetadataSource source,
219                                                          ArtifactFilter filter, List JavaDoc listeners )
220         throws ArtifactResolutionException, ArtifactNotFoundException
221     {
222         ArtifactResolutionResult artifactResolutionResult;
223         artifactResolutionResult = artifactCollector.collect( artifacts, originatingArtifact, managedVersions,
224                                                               localRepository, remoteRepositories, source, filter,
225                                                               listeners );
226
227         List JavaDoc missingArtifacts = new ArrayList JavaDoc();
228         for ( Iterator JavaDoc i = artifactResolutionResult.getArtifactResolutionNodes().iterator(); i.hasNext(); )
229         {
230             ResolutionNode node = (ResolutionNode) i.next();
231             try
232             {
233                 resolve( node.getArtifact(), node.getRemoteRepositories(), localRepository );
234             }
235             catch ( ArtifactNotFoundException anfe )
236             {
237                 getLogger().debug( anfe.getMessage() );
238                 missingArtifacts.add( node.getArtifact() );
239             }
240         }
241         
242         if ( missingArtifacts.size() > 0 )
243         {
244             throw new MultipleArtifactsNotFoundException( originatingArtifact, missingArtifacts, remoteRepositories );
245 // String message = "required artifacts missing:\n";
246
// for ( Iterator i = missingArtifacts.iterator(); i.hasNext(); )
247
// {
248
// Artifact missingArtifact = (Artifact) i.next();
249
// message += " " + missingArtifact.getId() + "\n";
250
// }
251
// message += "\nfor the artifact:";
252
// throw new ArtifactResolutionException( message, originatingArtifact, remoteRepositories );
253
}
254
255         return artifactResolutionResult;
256     }
257
258     public ArtifactResolutionResult resolveTransitively( Set JavaDoc artifacts, Artifact originatingArtifact,
259                                                          List JavaDoc remoteRepositories, ArtifactRepository localRepository,
260                                                          ArtifactMetadataSource source )
261         throws ArtifactResolutionException, ArtifactNotFoundException
262     {
263         return resolveTransitively( artifacts, originatingArtifact, localRepository, remoteRepositories, source, null );
264     }
265
266     public ArtifactResolutionResult resolveTransitively( Set JavaDoc artifacts, Artifact originatingArtifact,
267                                                          List JavaDoc remoteRepositories, ArtifactRepository localRepository,
268                                                          ArtifactMetadataSource source, List JavaDoc listeners )
269         throws ArtifactResolutionException, ArtifactNotFoundException
270     {
271         return resolveTransitively( artifacts, originatingArtifact, Collections.EMPTY_MAP, localRepository,
272                                     remoteRepositories, source, null, listeners );
273     }
274
275 }
276
Popular Tags