1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.repository.legacy;
20
21 import javax.inject.Inject;
22 import javax.inject.Named;
23 import javax.inject.Singleton;
24
25 import java.io.File;
26 import java.io.IOException;
27 import java.util.ArrayList;
28 import java.util.Collection;
29 import java.util.Collections;
30 import java.util.HashMap;
31 import java.util.LinkedHashMap;
32 import java.util.List;
33 import java.util.Map;
34
35 import org.apache.maven.RepositoryUtils;
36 import org.apache.maven.artifact.Artifact;
37 import org.apache.maven.artifact.InvalidRepositoryException;
38 import org.apache.maven.artifact.factory.ArtifactFactory;
39 import org.apache.maven.artifact.metadata.ArtifactMetadata;
40 import org.apache.maven.artifact.repository.ArtifactRepository;
41 import org.apache.maven.artifact.repository.ArtifactRepositoryPolicy;
42 import org.apache.maven.artifact.repository.Authentication;
43 import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout;
44 import org.apache.maven.artifact.resolver.ArtifactResolutionRequest;
45 import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
46 import org.apache.maven.artifact.resolver.ArtifactResolver;
47 import org.apache.maven.artifact.resolver.filter.ExcludesArtifactFilter;
48 import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
49 import org.apache.maven.artifact.versioning.VersionRange;
50 import org.apache.maven.model.Dependency;
51 import org.apache.maven.model.Exclusion;
52 import org.apache.maven.model.Plugin;
53 import org.apache.maven.model.Repository;
54 import org.apache.maven.model.RepositoryPolicy;
55 import org.apache.maven.repository.ArtifactDoesNotExistException;
56 import org.apache.maven.repository.ArtifactTransferFailedException;
57 import org.apache.maven.repository.ArtifactTransferListener;
58 import org.apache.maven.repository.DelegatingLocalArtifactRepository;
59 import org.apache.maven.repository.LocalArtifactRepository;
60 import org.apache.maven.repository.MirrorSelector;
61 import org.apache.maven.repository.Proxy;
62 import org.apache.maven.repository.RepositorySystem;
63 import org.apache.maven.repository.legacy.repository.ArtifactRepositoryFactory;
64 import org.apache.maven.settings.Mirror;
65 import org.apache.maven.settings.Server;
66 import org.apache.maven.settings.building.SettingsProblem;
67 import org.apache.maven.settings.crypto.DefaultSettingsDecryptionRequest;
68 import org.apache.maven.settings.crypto.SettingsDecrypter;
69 import org.apache.maven.settings.crypto.SettingsDecryptionRequest;
70 import org.apache.maven.settings.crypto.SettingsDecryptionResult;
71 import org.apache.maven.wagon.proxy.ProxyInfo;
72 import org.apache.maven.wagon.proxy.ProxyUtils;
73 import org.codehaus.plexus.PlexusContainer;
74 import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
75 import org.codehaus.plexus.logging.Logger;
76 import org.eclipse.aether.RepositorySystemSession;
77 import org.eclipse.aether.repository.AuthenticationContext;
78 import org.eclipse.aether.repository.AuthenticationSelector;
79 import org.eclipse.aether.repository.ProxySelector;
80 import org.eclipse.aether.repository.RemoteRepository;
81
82
83
84 @Named("default")
85 @Singleton
86 @Deprecated
87 public class LegacyRepositorySystem implements RepositorySystem {
88
89 @Inject
90 private Logger logger;
91
92 @Inject
93 private ArtifactFactory artifactFactory;
94
95 @Inject
96 private ArtifactResolver artifactResolver;
97
98 @Inject
99 private ArtifactRepositoryFactory artifactRepositoryFactory;
100
101 @Inject
102 private Map<String, ArtifactRepositoryLayout> layouts;
103
104 @Inject
105 private WagonManager wagonManager;
106
107 @Inject
108 private PlexusContainer plexus;
109
110 @Inject
111 private MirrorSelector mirrorSelector;
112
113 @Inject
114 private SettingsDecrypter settingsDecrypter;
115
116 @Override
117 public Artifact createArtifact(String groupId, String artifactId, String version, String scope, String type) {
118 return artifactFactory.createArtifact(groupId, artifactId, version, scope, type);
119 }
120
121 @Override
122 public Artifact createArtifact(String groupId, String artifactId, String version, String packaging) {
123 return artifactFactory.createBuildArtifact(groupId, artifactId, version, packaging);
124 }
125
126 @Override
127 public Artifact createArtifactWithClassifier(
128 String groupId, String artifactId, String version, String type, String classifier) {
129 return artifactFactory.createArtifactWithClassifier(groupId, artifactId, version, type, classifier);
130 }
131
132 @Override
133 public Artifact createProjectArtifact(String groupId, String artifactId, String metaVersionId) {
134 return artifactFactory.createProjectArtifact(groupId, artifactId, metaVersionId);
135 }
136
137 @Override
138 public Artifact createDependencyArtifact(Dependency d) {
139 VersionRange versionRange;
140 try {
141 versionRange = VersionRange.createFromVersionSpec(d.getVersion());
142 } catch (InvalidVersionSpecificationException e) {
143
144 this.logger.error(
145 String.format(
146 "Invalid version specification '%s' creating dependency artifact '%s'.", d.getVersion(), d),
147 e);
148 return null;
149 }
150
151 Artifact artifact = artifactFactory.createDependencyArtifact(
152 d.getGroupId(),
153 d.getArtifactId(),
154 versionRange,
155 d.getType(),
156 d.getClassifier(),
157 d.getScope(),
158 d.isOptional());
159
160 if (Artifact.SCOPE_SYSTEM.equals(d.getScope()) && d.getSystemPath() != null) {
161 artifact.setFile(new File(d.getSystemPath()));
162 }
163
164 if (!d.getExclusions().isEmpty()) {
165 List<String> exclusions = new ArrayList<>();
166
167 for (Exclusion exclusion : d.getExclusions()) {
168 exclusions.add(exclusion.getGroupId() + ':' + exclusion.getArtifactId());
169 }
170
171 artifact.setDependencyFilter(new ExcludesArtifactFilter(exclusions));
172 }
173
174 return artifact;
175 }
176
177 public Artifact createExtensionArtifact(String groupId, String artifactId, String version) {
178 VersionRange versionRange;
179 try {
180 versionRange = VersionRange.createFromVersionSpec(version);
181 } catch (InvalidVersionSpecificationException e) {
182
183 this.logger.error(
184 String.format(
185 "Invalid version specification '%s' creating extension artifact '%s:%s:%s'.",
186 version, groupId, artifactId, version),
187 e);
188
189 return null;
190 }
191
192 return artifactFactory.createExtensionArtifact(groupId, artifactId, versionRange);
193 }
194
195 public Artifact createParentArtifact(String groupId, String artifactId, String version) {
196 return artifactFactory.createParentArtifact(groupId, artifactId, version);
197 }
198
199 @Override
200 public Artifact createPluginArtifact(Plugin plugin) {
201 String version = plugin.getVersion();
202 if (version == null || version.isEmpty()) {
203 version = "RELEASE";
204 }
205
206 VersionRange versionRange;
207 try {
208 versionRange = VersionRange.createFromVersionSpec(version);
209 } catch (InvalidVersionSpecificationException e) {
210
211 this.logger.error(
212 String.format("Invalid version specification '%s' creating plugin artifact '%s'.", version, plugin),
213 e);
214
215 return null;
216 }
217
218 return artifactFactory.createPluginArtifact(plugin.getGroupId(), plugin.getArtifactId(), versionRange);
219 }
220
221 public ArtifactRepositoryPolicy buildArtifactRepositoryPolicy(RepositoryPolicy policy) {
222 boolean enabled = true;
223
224 String updatePolicy = null;
225
226 String checksumPolicy = null;
227
228 if (policy != null) {
229 enabled = policy.isEnabled();
230
231 if (policy.getUpdatePolicy() != null) {
232 updatePolicy = policy.getUpdatePolicy();
233 }
234 if (policy.getChecksumPolicy() != null) {
235 checksumPolicy = policy.getChecksumPolicy();
236 }
237 }
238
239 return new ArtifactRepositoryPolicy(enabled, updatePolicy, checksumPolicy);
240 }
241
242 @Override
243 public ArtifactRepository createDefaultLocalRepository() throws InvalidRepositoryException {
244 return createLocalRepository(RepositorySystem.defaultUserLocalRepository);
245 }
246
247 @Override
248 public ArtifactRepository createLocalRepository(File localRepository) throws InvalidRepositoryException {
249 return createRepository(
250 "file://" + localRepository.toURI().getRawPath(),
251 RepositorySystem.DEFAULT_LOCAL_REPO_ID,
252 true,
253 ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS,
254 true,
255 ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS,
256 ArtifactRepositoryPolicy.CHECKSUM_POLICY_IGNORE);
257 }
258
259 @Override
260 public ArtifactRepository createDefaultRemoteRepository() throws InvalidRepositoryException {
261 return createRepository(
262 RepositorySystem.DEFAULT_REMOTE_REPO_URL,
263 RepositorySystem.DEFAULT_REMOTE_REPO_ID,
264 true,
265 ArtifactRepositoryPolicy.UPDATE_POLICY_DAILY,
266 false,
267 ArtifactRepositoryPolicy.UPDATE_POLICY_DAILY,
268 ArtifactRepositoryPolicy.CHECKSUM_POLICY_WARN);
269 }
270
271 public ArtifactRepository createLocalRepository(String url, String repositoryId) throws IOException {
272 return createRepository(
273 canonicalFileUrl(url),
274 repositoryId,
275 true,
276 ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS,
277 true,
278 ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS,
279 ArtifactRepositoryPolicy.CHECKSUM_POLICY_IGNORE);
280 }
281
282 private String canonicalFileUrl(String url) throws IOException {
283 if (!url.startsWith("file:")) {
284 url = "file://" + url;
285 } else if (url.startsWith("file:") && !url.startsWith("file://")) {
286 url = "file://" + url.substring("file:".length());
287 }
288
289
290
291
292
293
294
295
296 File localRepository = new File(url.substring("file://".length()));
297
298 if (!localRepository.isAbsolute()) {
299 url = "file://" + localRepository.getCanonicalPath();
300 }
301
302 return url;
303 }
304
305 @Override
306 public ArtifactResolutionResult resolve(ArtifactResolutionRequest request) {
307
308
309
310
311 try {
312 LocalArtifactRepository ideWorkspace =
313 plexus.lookup(LocalArtifactRepository.class, LocalArtifactRepository.IDE_WORKSPACE);
314
315 if (request.getLocalRepository() instanceof DelegatingLocalArtifactRepository delegatingLocalRepository) {
316 LocalArtifactRepository orig = delegatingLocalRepository.getIdeWorkspace();
317
318 delegatingLocalRepository.setIdeWorkspace(ideWorkspace);
319
320 try {
321 return artifactResolver.resolve(request);
322 } finally {
323 delegatingLocalRepository.setIdeWorkspace(orig);
324 }
325 } else {
326 ArtifactRepository localRepository = request.getLocalRepository();
327 DelegatingLocalArtifactRepository delegatingLocalRepository =
328 new DelegatingLocalArtifactRepository(localRepository);
329 delegatingLocalRepository.setIdeWorkspace(ideWorkspace);
330 request.setLocalRepository(delegatingLocalRepository);
331 try {
332 return artifactResolver.resolve(request);
333 } finally {
334 request.setLocalRepository(localRepository);
335 }
336 }
337 } catch (ComponentLookupException e) {
338
339 }
340
341 return artifactResolver.resolve(request);
342 }
343
344 @Override
345 public List<ArtifactRepository> getEffectiveRepositories(List<ArtifactRepository> repositories) {
346 if (repositories == null) {
347 return null;
348 }
349
350 Map<String, List<ArtifactRepository>> reposByKey = new LinkedHashMap<>();
351
352 for (ArtifactRepository repository : repositories) {
353 String key = repository.getId();
354
355 List<ArtifactRepository> aliasedRepos = reposByKey.computeIfAbsent(key, k -> new ArrayList<>());
356
357 aliasedRepos.add(repository);
358 }
359
360 List<ArtifactRepository> effectiveRepositories = new ArrayList<>();
361
362 for (List<ArtifactRepository> aliasedRepos : reposByKey.values()) {
363 List<ArtifactRepository> mirroredRepos = new ArrayList<>();
364
365 List<ArtifactRepositoryPolicy> releasePolicies = new ArrayList<>(aliasedRepos.size());
366
367 for (ArtifactRepository aliasedRepo : aliasedRepos) {
368 releasePolicies.add(aliasedRepo.getReleases());
369 mirroredRepos.addAll(aliasedRepo.getMirroredRepositories());
370 }
371
372 ArtifactRepositoryPolicy releasePolicy = getEffectivePolicy(releasePolicies);
373
374 List<ArtifactRepositoryPolicy> snapshotPolicies = new ArrayList<>(aliasedRepos.size());
375
376 for (ArtifactRepository aliasedRepo : aliasedRepos) {
377 snapshotPolicies.add(aliasedRepo.getSnapshots());
378 }
379
380 ArtifactRepositoryPolicy snapshotPolicy = getEffectivePolicy(snapshotPolicies);
381
382 ArtifactRepository aliasedRepo = aliasedRepos.get(0);
383
384 ArtifactRepository effectiveRepository = createArtifactRepository(
385 aliasedRepo.getId(), aliasedRepo.getUrl(), aliasedRepo.getLayout(), snapshotPolicy, releasePolicy);
386
387 effectiveRepository.setAuthentication(aliasedRepo.getAuthentication());
388
389 effectiveRepository.setProxy(aliasedRepo.getProxy());
390
391 effectiveRepository.setMirroredRepositories(mirroredRepos);
392
393 effectiveRepository.setBlocked(aliasedRepo.isBlocked());
394
395 effectiveRepositories.add(effectiveRepository);
396 }
397
398 return effectiveRepositories;
399 }
400
401 private ArtifactRepositoryPolicy getEffectivePolicy(Collection<ArtifactRepositoryPolicy> policies) {
402 ArtifactRepositoryPolicy effectivePolicy = null;
403
404 for (ArtifactRepositoryPolicy policy : policies) {
405 if (effectivePolicy == null) {
406 effectivePolicy = new ArtifactRepositoryPolicy(policy);
407 } else {
408 effectivePolicy.merge(policy);
409 }
410 }
411
412 return effectivePolicy;
413 }
414
415 @Override
416 public Mirror getMirror(ArtifactRepository repository, List<Mirror> mirrors) {
417 return mirrorSelector.getMirror(repository, mirrors);
418 }
419
420 @Override
421 public void injectMirror(List<ArtifactRepository> repositories, List<Mirror> mirrors) {
422 if (repositories != null && mirrors != null) {
423 for (ArtifactRepository repository : repositories) {
424 Mirror mirror = getMirror(repository, mirrors);
425 injectMirror(repository, mirror);
426 }
427 }
428 }
429
430 private Mirror getMirror(RepositorySystemSession session, ArtifactRepository repository) {
431 if (session != null) {
432 org.eclipse.aether.repository.MirrorSelector selector = session.getMirrorSelector();
433 if (selector != null) {
434 RemoteRepository repo = selector.getMirror(RepositoryUtils.toRepo(repository));
435 if (repo != null) {
436 Mirror mirror = new Mirror();
437 mirror.setId(repo.getId());
438 mirror.setUrl(repo.getUrl());
439 mirror.setLayout(repo.getContentType());
440 mirror.setBlocked(repo.isBlocked());
441 return mirror;
442 }
443 }
444 }
445 return null;
446 }
447
448 @Override
449 public void injectMirror(RepositorySystemSession session, List<ArtifactRepository> repositories) {
450 if (repositories != null && session != null) {
451 for (ArtifactRepository repository : repositories) {
452 Mirror mirror = getMirror(session, repository);
453 injectMirror(repository, mirror);
454 }
455 }
456 }
457
458 private void injectMirror(ArtifactRepository repository, Mirror mirror) {
459 if (mirror != null) {
460 ArtifactRepository original = createArtifactRepository(
461 repository.getId(),
462 repository.getUrl(),
463 repository.getLayout(),
464 repository.getSnapshots(),
465 repository.getReleases());
466
467 repository.setMirroredRepositories(Collections.singletonList(original));
468
469 repository.setId(mirror.getId());
470 repository.setUrl(mirror.getUrl());
471
472 if (mirror.getLayout() != null && !mirror.getLayout().isEmpty()) {
473 repository.setLayout(getLayout(mirror.getLayout()));
474 }
475
476 repository.setBlocked(mirror.isBlocked());
477 }
478 }
479
480 @Override
481 public void injectAuthentication(List<ArtifactRepository> repositories, List<Server> servers) {
482 if (repositories != null) {
483 Map<String, Server> serversById = new HashMap<>();
484
485 if (servers != null) {
486 for (Server server : servers) {
487 if (!serversById.containsKey(server.getId())) {
488 serversById.put(server.getId(), server);
489 }
490 }
491 }
492
493 for (ArtifactRepository repository : repositories) {
494 Server server = serversById.get(repository.getId());
495
496 if (server != null) {
497 SettingsDecryptionRequest request = new DefaultSettingsDecryptionRequest(server);
498 SettingsDecryptionResult result = settingsDecrypter.decrypt(request);
499 server = result.getServer();
500
501 if (logger.isDebugEnabled()) {
502 for (SettingsProblem problem : result.getProblems()) {
503 logger.debug(problem.getMessage(), problem.getException());
504 }
505 }
506
507 Authentication authentication = new Authentication(server.getUsername(), server.getPassword());
508 authentication.setPrivateKey(server.getPrivateKey());
509 authentication.setPassphrase(server.getPassphrase());
510
511 repository.setAuthentication(authentication);
512 } else {
513 repository.setAuthentication(null);
514 }
515 }
516 }
517 }
518
519 private Authentication getAuthentication(RepositorySystemSession session, ArtifactRepository repository) {
520 if (session != null) {
521 AuthenticationSelector selector = session.getAuthenticationSelector();
522 if (selector != null) {
523 RemoteRepository repo = RepositoryUtils.toRepo(repository);
524 org.eclipse.aether.repository.Authentication auth = selector.getAuthentication(repo);
525 if (auth != null) {
526 repo = new RemoteRepository.Builder(repo)
527 .setAuthentication(auth)
528 .build();
529 AuthenticationContext authCtx = AuthenticationContext.forRepository(session, repo);
530 Authentication result = new Authentication(
531 authCtx.get(AuthenticationContext.USERNAME), authCtx.get(AuthenticationContext.PASSWORD));
532 result.setPrivateKey(authCtx.get(AuthenticationContext.PRIVATE_KEY_PATH));
533 result.setPassphrase(authCtx.get(AuthenticationContext.PRIVATE_KEY_PASSPHRASE));
534 authCtx.close();
535 return result;
536 }
537 }
538 }
539 return null;
540 }
541
542 @Override
543 public void injectAuthentication(RepositorySystemSession session, List<ArtifactRepository> repositories) {
544 if (repositories != null && session != null) {
545 for (ArtifactRepository repository : repositories) {
546 repository.setAuthentication(getAuthentication(session, repository));
547 }
548 }
549 }
550
551 private org.apache.maven.settings.Proxy getProxy(
552 ArtifactRepository repository, List<org.apache.maven.settings.Proxy> proxies) {
553 if (proxies != null && repository.getProtocol() != null) {
554 for (org.apache.maven.settings.Proxy proxy : proxies) {
555 if (proxy.isActive() && repository.getProtocol().equalsIgnoreCase(proxy.getProtocol())) {
556 if (proxy.getNonProxyHosts() != null
557 && !proxy.getNonProxyHosts().isEmpty()) {
558 ProxyInfo pi = new ProxyInfo();
559 pi.setNonProxyHosts(proxy.getNonProxyHosts());
560
561 org.apache.maven.wagon.repository.Repository repo =
562 new org.apache.maven.wagon.repository.Repository(
563 repository.getId(), repository.getUrl());
564
565 if (!ProxyUtils.validateNonProxyHosts(pi, repo.getHost())) {
566 return proxy;
567 }
568 } else {
569 return proxy;
570 }
571 }
572 }
573 }
574
575 return null;
576 }
577
578 @Override
579 public void injectProxy(List<ArtifactRepository> repositories, List<org.apache.maven.settings.Proxy> proxies) {
580 if (repositories != null) {
581 for (ArtifactRepository repository : repositories) {
582 org.apache.maven.settings.Proxy proxy = getProxy(repository, proxies);
583
584 if (proxy != null) {
585 SettingsDecryptionRequest request = new DefaultSettingsDecryptionRequest(proxy);
586 SettingsDecryptionResult result = settingsDecrypter.decrypt(request);
587 proxy = result.getProxy();
588
589 if (logger.isDebugEnabled()) {
590 for (SettingsProblem problem : result.getProblems()) {
591 logger.debug(problem.getMessage(), problem.getException());
592 }
593 }
594
595 Proxy p = new Proxy();
596 p.setHost(proxy.getHost());
597 p.setProtocol(proxy.getProtocol());
598 p.setPort(proxy.getPort());
599 p.setNonProxyHosts(proxy.getNonProxyHosts());
600 p.setUserName(proxy.getUsername());
601 p.setPassword(proxy.getPassword());
602
603 repository.setProxy(p);
604 } else {
605 repository.setProxy(null);
606 }
607 }
608 }
609 }
610
611 private Proxy getProxy(RepositorySystemSession session, ArtifactRepository repository) {
612 if (session != null) {
613 ProxySelector selector = session.getProxySelector();
614 if (selector != null) {
615 RemoteRepository repo = RepositoryUtils.toRepo(repository);
616 org.eclipse.aether.repository.Proxy proxy = selector.getProxy(repo);
617 if (proxy != null) {
618 Proxy p = new Proxy();
619 p.setHost(proxy.getHost());
620 p.setProtocol(proxy.getType());
621 p.setPort(proxy.getPort());
622 if (proxy.getAuthentication() != null) {
623 repo = new RemoteRepository.Builder(repo)
624 .setProxy(proxy)
625 .build();
626 AuthenticationContext authCtx = AuthenticationContext.forProxy(session, repo);
627 p.setUserName(authCtx.get(AuthenticationContext.USERNAME));
628 p.setPassword(authCtx.get(AuthenticationContext.PASSWORD));
629 p.setNtlmDomain(authCtx.get(AuthenticationContext.NTLM_DOMAIN));
630 p.setNtlmHost(authCtx.get(AuthenticationContext.NTLM_WORKSTATION));
631 authCtx.close();
632 }
633 return p;
634 }
635 }
636 }
637 return null;
638 }
639
640 @Override
641 public void injectProxy(RepositorySystemSession session, List<ArtifactRepository> repositories) {
642 if (repositories != null && session != null) {
643 for (ArtifactRepository repository : repositories) {
644 repository.setProxy(getProxy(session, repository));
645 }
646 }
647 }
648
649 @Override
650 public void retrieve(
651 ArtifactRepository repository,
652 File destination,
653 String remotePath,
654 ArtifactTransferListener transferListener)
655 throws ArtifactTransferFailedException, ArtifactDoesNotExistException {
656 try {
657 wagonManager.getRemoteFile(
658 repository,
659 destination,
660 remotePath,
661 TransferListenerAdapter.newAdapter(transferListener),
662 ArtifactRepositoryPolicy.CHECKSUM_POLICY_WARN,
663 true);
664 } catch (org.apache.maven.wagon.TransferFailedException e) {
665 throw new ArtifactTransferFailedException(getMessage(e, "Error transferring artifact."), e);
666 } catch (org.apache.maven.wagon.ResourceDoesNotExistException e) {
667 throw new ArtifactDoesNotExistException(getMessage(e, "Requested artifact does not exist."), e);
668 }
669 }
670
671 @Override
672 public void publish(
673 ArtifactRepository repository, File source, String remotePath, ArtifactTransferListener transferListener)
674 throws ArtifactTransferFailedException {
675 try {
676 wagonManager.putRemoteFile(
677 repository, source, remotePath, TransferListenerAdapter.newAdapter(transferListener));
678 } catch (org.apache.maven.wagon.TransferFailedException e) {
679 throw new ArtifactTransferFailedException(getMessage(e, "Error transferring artifact."), e);
680 }
681 }
682
683
684
685
686 @Override
687 public ArtifactRepository buildArtifactRepository(Repository repo) throws InvalidRepositoryException {
688 if (repo != null) {
689 String id = repo.getId();
690
691 if (id == null || id.isEmpty()) {
692 throw new InvalidRepositoryException("Repository identifier missing", "");
693 }
694
695 String url = repo.getUrl();
696
697 if (url == null || url.isEmpty()) {
698 throw new InvalidRepositoryException("URL missing for repository " + id, id);
699 }
700
701 ArtifactRepositoryPolicy snapshots = buildArtifactRepositoryPolicy(repo.getSnapshots());
702
703 ArtifactRepositoryPolicy releases = buildArtifactRepositoryPolicy(repo.getReleases());
704
705 return createArtifactRepository(id, url, getLayout(repo.getLayout()), snapshots, releases);
706 } else {
707 return null;
708 }
709 }
710
711 private ArtifactRepository createRepository(
712 String url,
713 String repositoryId,
714 boolean releases,
715 String releaseUpdates,
716 boolean snapshots,
717 String snapshotUpdates,
718 String checksumPolicy) {
719 ArtifactRepositoryPolicy snapshotsPolicy =
720 new ArtifactRepositoryPolicy(snapshots, snapshotUpdates, checksumPolicy);
721
722 ArtifactRepositoryPolicy releasesPolicy =
723 new ArtifactRepositoryPolicy(releases, releaseUpdates, checksumPolicy);
724
725 return createArtifactRepository(repositoryId, url, null, snapshotsPolicy, releasesPolicy);
726 }
727
728 @Override
729 public ArtifactRepository createArtifactRepository(
730 String repositoryId,
731 String url,
732 ArtifactRepositoryLayout repositoryLayout,
733 ArtifactRepositoryPolicy snapshots,
734 ArtifactRepositoryPolicy releases) {
735 if (repositoryLayout == null) {
736 repositoryLayout = layouts.get("default");
737 }
738 return artifactRepositoryFactory.createArtifactRepository(
739 repositoryId, url, repositoryLayout, snapshots, releases);
740 }
741
742 private static String getMessage(Throwable error, String def) {
743 if (error == null) {
744 return def;
745 }
746 String msg = error.getMessage();
747 if (msg != null && !msg.isEmpty()) {
748 return msg;
749 }
750 return getMessage(error.getCause(), def);
751 }
752
753 private ArtifactRepositoryLayout getLayout(String id) {
754 ArtifactRepositoryLayout layout = layouts.get(id);
755
756 if (layout == null) {
757 layout = new UnknownRepositoryLayout(id, layouts.get("default"));
758 }
759
760 return layout;
761 }
762
763
764
765
766
767
768
769 static class UnknownRepositoryLayout implements ArtifactRepositoryLayout {
770
771 private final String id;
772
773 private final ArtifactRepositoryLayout fallback;
774
775 UnknownRepositoryLayout(String id, ArtifactRepositoryLayout fallback) {
776 this.id = id;
777 this.fallback = fallback;
778 }
779
780 @Override
781 public String getId() {
782 return id;
783 }
784
785 @Override
786 public String pathOf(Artifact artifact) {
787 return fallback.pathOf(artifact);
788 }
789
790 @Override
791 public String pathOfLocalRepositoryMetadata(ArtifactMetadata metadata, ArtifactRepository repository) {
792 return fallback.pathOfLocalRepositoryMetadata(metadata, repository);
793 }
794
795 @Override
796 public String pathOfRemoteRepositoryMetadata(ArtifactMetadata metadata) {
797 return fallback.pathOfRemoteRepositoryMetadata(metadata);
798 }
799
800 @Override
801 public String toString() {
802 return getId();
803 }
804 }
805 }