1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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 }