View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  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,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.eclipse.aether.internal.impl;
20  
21  import javax.inject.Inject;
22  import javax.inject.Named;
23  import javax.inject.Singleton;
24  
25  import java.util.ArrayList;
26  import java.util.Collection;
27  import java.util.List;
28  
29  import org.eclipse.aether.RepositorySystemSession;
30  import org.eclipse.aether.artifact.Artifact;
31  import org.eclipse.aether.collection.CollectRequest;
32  import org.eclipse.aether.deployment.DeployRequest;
33  import org.eclipse.aether.graph.Dependency;
34  import org.eclipse.aether.impl.RepositorySystemValidator;
35  import org.eclipse.aether.installation.InstallRequest;
36  import org.eclipse.aether.metadata.Metadata;
37  import org.eclipse.aether.repository.LocalRepository;
38  import org.eclipse.aether.repository.RemoteRepository;
39  import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
40  import org.eclipse.aether.resolution.ArtifactRequest;
41  import org.eclipse.aether.resolution.DependencyRequest;
42  import org.eclipse.aether.resolution.MetadataRequest;
43  import org.eclipse.aether.resolution.VersionRangeRequest;
44  import org.eclipse.aether.resolution.VersionRequest;
45  import org.eclipse.aether.spi.validator.Validator;
46  import org.eclipse.aether.spi.validator.ValidatorFactory;
47  
48  import static java.util.Objects.requireNonNull;
49  
50  @Singleton
51  @Named
52  public class DefaultRepositorySystemValidator implements RepositorySystemValidator {
53      private final List<ValidatorFactory> validatorFactories;
54  
55      @Inject
56      public DefaultRepositorySystemValidator(List<ValidatorFactory> validatorFactories) {
57          this.validatorFactories = requireNonNull(validatorFactories, "validatorFactories cannot be null");
58      }
59  
60      private void mayThrow(List<Exception> exceptions, String message) {
61          if (!exceptions.isEmpty()) {
62              IllegalArgumentException result = new IllegalArgumentException(message);
63              exceptions.forEach(result::addSuppressed);
64              throw result;
65          }
66      }
67  
68      @Override
69      public void validateVersionRequest(RepositorySystemSession session, VersionRequest request) {
70          ArrayList<Exception> exceptions = new ArrayList<>();
71          for (ValidatorFactory factory : validatorFactories) {
72              Validator validator = factory.newInstance(session);
73              try {
74                  validator.validateArtifact(request.getArtifact());
75              } catch (Exception e) {
76                  exceptions.add(e);
77              }
78              for (RemoteRepository repository : request.getRepositories()) {
79                  try {
80                      validator.validateRemoteRepository(repository);
81                  } catch (Exception e) {
82                      exceptions.add(e);
83                  }
84              }
85          }
86          mayThrow(exceptions, "Invalid Version Request: " + request);
87      }
88  
89      @Override
90      public void validateVersionRangeRequest(RepositorySystemSession session, VersionRangeRequest request) {
91          ArrayList<Exception> exceptions = new ArrayList<>();
92          for (ValidatorFactory factory : validatorFactories) {
93              Validator validator = factory.newInstance(session);
94              try {
95                  validator.validateArtifact(request.getArtifact());
96              } catch (Exception e) {
97                  exceptions.add(e);
98              }
99              for (RemoteRepository repository : request.getRepositories()) {
100                 try {
101                     validator.validateRemoteRepository(repository);
102                 } catch (Exception e) {
103                     exceptions.add(e);
104                 }
105             }
106         }
107         mayThrow(exceptions, "Invalid Version Range Request: " + request);
108     }
109 
110     @Override
111     public void validateArtifactDescriptorRequest(RepositorySystemSession session, ArtifactDescriptorRequest request) {
112         ArrayList<Exception> exceptions = new ArrayList<>();
113         for (ValidatorFactory factory : validatorFactories) {
114             Validator validator = factory.newInstance(session);
115             try {
116                 validator.validateArtifact(request.getArtifact());
117             } catch (Exception e) {
118                 exceptions.add(e);
119             }
120             for (RemoteRepository repository : request.getRepositories()) {
121                 try {
122                     validator.validateRemoteRepository(repository);
123                 } catch (Exception e) {
124                     exceptions.add(e);
125                 }
126             }
127         }
128         mayThrow(exceptions, "Invalid Artifact Descriptor Request: " + request);
129     }
130 
131     @Override
132     public void validateArtifactRequests(
133             RepositorySystemSession session, Collection<? extends ArtifactRequest> requests) {
134         ArrayList<Exception> exceptions = new ArrayList<>();
135         for (ValidatorFactory factory : validatorFactories) {
136             Validator validator = factory.newInstance(session);
137             for (ArtifactRequest request : requests) {
138                 try {
139                     validator.validateArtifact(request.getArtifact());
140                 } catch (Exception e) {
141                     exceptions.add(e);
142                 }
143                 for (RemoteRepository repository : request.getRepositories()) {
144                     try {
145                         validator.validateRemoteRepository(repository);
146                     } catch (Exception e) {
147                         exceptions.add(e);
148                     }
149                 }
150             }
151         }
152         mayThrow(exceptions, "Invalid Artifact Requests: " + requests);
153     }
154 
155     @Override
156     public void validateMetadataRequests(
157             RepositorySystemSession session, Collection<? extends MetadataRequest> requests) {
158         ArrayList<Exception> exceptions = new ArrayList<>();
159         for (ValidatorFactory factory : validatorFactories) {
160             Validator validator = factory.newInstance(session);
161             for (MetadataRequest request : requests) {
162                 try {
163                     validator.validateMetadata(request.getMetadata());
164                 } catch (Exception e) {
165                     exceptions.add(e);
166                 }
167                 try {
168                     if (request.getRepository() != null) {
169                         validator.validateRemoteRepository(request.getRepository());
170                     }
171                 } catch (Exception e) {
172                     exceptions.add(e);
173                 }
174             }
175         }
176         mayThrow(exceptions, "Invalid Metadata Requests: " + requests);
177     }
178 
179     @Override
180     public void validateCollectRequest(RepositorySystemSession session, CollectRequest request) {
181         ArrayList<Exception> exceptions = new ArrayList<>();
182         for (ValidatorFactory factory : validatorFactories) {
183             Validator validator = factory.newInstance(session);
184             if (request.getRootArtifact() != null) {
185                 try {
186                     validator.validateArtifact(request.getRootArtifact());
187                 } catch (Exception e) {
188                     exceptions.add(e);
189                 }
190             }
191             if (request.getRoot() != null) {
192                 try {
193                     validator.validateDependency(request.getRoot());
194                 } catch (Exception e) {
195                     exceptions.add(e);
196                 }
197             }
198             for (Dependency dependency : request.getDependencies()) {
199                 try {
200                     validator.validateDependency(dependency);
201                 } catch (Exception e) {
202                     exceptions.add(e);
203                 }
204             }
205             for (Dependency managedDependency : request.getManagedDependencies()) {
206                 try {
207                     validator.validateDependency(managedDependency);
208                 } catch (Exception e) {
209                     exceptions.add(e);
210                 }
211             }
212             for (RemoteRepository repository : request.getRepositories()) {
213                 try {
214                     validator.validateRemoteRepository(repository);
215                 } catch (Exception e) {
216                     exceptions.add(e);
217                 }
218             }
219         }
220         mayThrow(exceptions, "Invalid Collect Request: " + request);
221     }
222 
223     @Override
224     public void validateDependencyRequest(RepositorySystemSession session, DependencyRequest request) {
225         if (request.getCollectRequest() != null) {
226             try {
227                 validateCollectRequest(session, request.getCollectRequest());
228             } catch (Exception e) {
229                 throw new IllegalArgumentException("Invalid Dependency Request: " + request, e);
230             }
231         }
232     }
233 
234     @Override
235     public void validateInstallRequest(RepositorySystemSession session, InstallRequest request) {
236         ArrayList<Exception> exceptions = new ArrayList<>();
237         for (ValidatorFactory factory : validatorFactories) {
238             Validator validator = factory.newInstance(session);
239             for (Artifact artifact : request.getArtifacts()) {
240                 try {
241                     validator.validateArtifact(artifact);
242                 } catch (Exception e) {
243                     exceptions.add(e);
244                 }
245             }
246             for (Metadata metadata : request.getMetadata()) {
247                 try {
248                     validator.validateMetadata(metadata);
249                 } catch (Exception e) {
250                     exceptions.add(e);
251                 }
252             }
253         }
254         mayThrow(exceptions, "Invalid Install Request: " + request);
255     }
256 
257     @Override
258     public void validateDeployRequest(RepositorySystemSession session, DeployRequest request) {
259         ArrayList<Exception> exceptions = new ArrayList<>();
260         for (ValidatorFactory factory : validatorFactories) {
261             Validator validator = factory.newInstance(session);
262             for (Artifact artifact : request.getArtifacts()) {
263                 try {
264                     validator.validateArtifact(artifact);
265                 } catch (Exception e) {
266                     exceptions.add(e);
267                 }
268             }
269             for (Metadata metadata : request.getMetadata()) {
270                 try {
271                     validator.validateMetadata(metadata);
272                 } catch (Exception e) {
273                     exceptions.add(e);
274                 }
275             }
276             try {
277                 if (request.getRepository() != null) {
278                     validator.validateRemoteRepository(request.getRepository());
279                 }
280             } catch (Exception e) {
281                 exceptions.add(e);
282             }
283         }
284         mayThrow(exceptions, "Invalid Deploy Request: " + request);
285     }
286 
287     @Override
288     public void validateLocalRepositories(RepositorySystemSession session, Collection<LocalRepository> repositories) {
289         ArrayList<Exception> exceptions = new ArrayList<>();
290         for (ValidatorFactory factory : validatorFactories) {
291             Validator validator = factory.newInstance(session);
292             for (LocalRepository repository : repositories) {
293                 try {
294                     validator.validateLocalRepository(repository);
295                 } catch (Exception e) {
296                     exceptions.add(e);
297                 }
298             }
299         }
300         mayThrow(exceptions, "Invalid LocalRepositories: " + repositories);
301     }
302 
303     @Override
304     public void validateRemoteRepositories(RepositorySystemSession session, Collection<RemoteRepository> repositories) {
305         ArrayList<Exception> exceptions = new ArrayList<>();
306         for (ValidatorFactory factory : validatorFactories) {
307             Validator validator = factory.newInstance(session);
308             for (RemoteRepository repository : repositories) {
309                 try {
310                     validator.validateRemoteRepository(repository);
311                 } catch (Exception e) {
312                     exceptions.add(e);
313                 }
314             }
315         }
316         mayThrow(exceptions, "Invalid RemoteRepositories: " + repositories);
317     }
318 }