Java tutorial
package org.apache.maven.bridge; /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ import java.io.File; import java.net.MalformedURLException; import java.net.URL; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Set; import org.apache.maven.RepositoryUtils; import org.apache.maven.artifact.Artifact; import org.apache.maven.artifact.DefaultArtifact; import org.apache.maven.artifact.InvalidRepositoryException; import org.apache.maven.artifact.handler.ArtifactHandler; import org.apache.maven.artifact.handler.manager.ArtifactHandlerManager; import org.apache.maven.artifact.repository.ArtifactRepository; import org.apache.maven.artifact.repository.ArtifactRepositoryPolicy; import org.apache.maven.artifact.repository.Authentication; import org.apache.maven.artifact.repository.MavenArtifactRepository; import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout; import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout2; import org.apache.maven.artifact.repository.layout.DefaultRepositoryLayout; import org.apache.maven.artifact.resolver.filter.ExclusionArtifactFilter; import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException; import org.apache.maven.artifact.versioning.VersionRange; import org.apache.maven.execution.MavenExecutionRequest; import org.apache.maven.model.Dependency; import org.apache.maven.model.Plugin; import org.apache.maven.repository.Proxy; import org.apache.maven.repository.RepositorySystem; import org.apache.maven.settings.Mirror; import org.codehaus.plexus.component.annotations.Component; import org.codehaus.plexus.component.annotations.Requirement; import org.codehaus.plexus.util.StringUtils; import org.eclipse.aether.RepositorySystemSession; import org.eclipse.aether.repository.AuthenticationContext; import org.eclipse.aether.repository.AuthenticationSelector; import org.eclipse.aether.repository.ProxySelector; import org.eclipse.aether.repository.RemoteRepository; /** * @author Jason van Zyl */ @Component(role = MavenRepositorySystem.class, hint = "default") public class MavenRepositorySystem { @Requirement private ArtifactHandlerManager artifactHandlerManager; @Requirement(role = ArtifactRepositoryLayout.class) private Map<String, ArtifactRepositoryLayout> layouts; // DefaultProjectBuilder public Artifact createArtifact(String groupId, String artifactId, String version, String scope, String type) { return createArtifactX(groupId, artifactId, version, scope, type); } // DefaultProjectBuilder public Artifact createProjectArtifact(String groupId, String artifactId, String metaVersionId) { return createProjectArtifactX(groupId, artifactId, metaVersionId); } // DefaultProjectBuilder public Artifact createDependencyArtifact(Dependency d) { if (d.getVersion() == null) { return null; } VersionRange versionRange; try { versionRange = VersionRange.createFromVersionSpec(d.getVersion()); } catch (InvalidVersionSpecificationException e) { return null; } Artifact artifact = createDependencyArtifactX(d.getGroupId(), d.getArtifactId(), versionRange, d.getType(), d.getClassifier(), d.getScope(), d.isOptional()); if (Artifact.SCOPE_SYSTEM.equals(d.getScope()) && d.getSystemPath() != null) { artifact.setFile(new File(d.getSystemPath())); } if (!d.getExclusions().isEmpty()) { artifact.setDependencyFilter(new ExclusionArtifactFilter(d.getExclusions())); } return artifact; } // DefaultProjectBuilder public Artifact createExtensionArtifact(String groupId, String artifactId, String version) { VersionRange versionRange; try { versionRange = VersionRange.createFromVersionSpec(version); } catch (InvalidVersionSpecificationException e) { return null; } return createExtensionArtifactX(groupId, artifactId, versionRange); } // DefaultProjectBuilder public Artifact createParentArtifact(String groupId, String artifactId, String version) { return createParentArtifactX(groupId, artifactId, version); } // DefaultProjectBuilder public Artifact createPluginArtifact(Plugin plugin) { VersionRange versionRange; try { String version = plugin.getVersion(); if (StringUtils.isEmpty(version)) { version = "RELEASE"; } versionRange = VersionRange.createFromVersionSpec(version); } catch (InvalidVersionSpecificationException e) { return null; } return createPluginArtifactX(plugin.getGroupId(), plugin.getArtifactId(), versionRange); } public void injectMirror(List<ArtifactRepository> repositories, List<Mirror> mirrors) { if (repositories != null && mirrors != null) { for (ArtifactRepository repository : repositories) { Mirror mirror = getMirror(repository, mirrors); injectMirror(repository, mirror); } } } private Mirror getMirror(RepositorySystemSession session, ArtifactRepository repository) { if (session != null) { org.eclipse.aether.repository.MirrorSelector selector = session.getMirrorSelector(); if (selector != null) { RemoteRepository repo = selector.getMirror(RepositoryUtils.toRepo(repository)); if (repo != null) { Mirror mirror = new Mirror(); mirror.setId(repo.getId()); mirror.setUrl(repo.getUrl()); mirror.setLayout(repo.getContentType()); return mirror; } } } return null; } public void injectMirror(RepositorySystemSession session, List<ArtifactRepository> repositories) { if (repositories != null && session != null) { for (ArtifactRepository repository : repositories) { Mirror mirror = getMirror(session, repository); injectMirror(repository, mirror); } } } private void injectMirror(ArtifactRepository repository, Mirror mirror) { if (mirror != null) { ArtifactRepository original = createArtifactRepository(repository.getId(), repository.getUrl(), repository.getLayout(), repository.getSnapshots(), repository.getReleases()); repository.setMirroredRepositories(Collections.singletonList(original)); repository.setId(mirror.getId()); repository.setUrl(mirror.getUrl()); if (StringUtils.isNotEmpty(mirror.getLayout())) { repository.setLayout(getLayout(mirror.getLayout())); } } } private Authentication getAuthentication(RepositorySystemSession session, ArtifactRepository repository) { if (session != null) { AuthenticationSelector selector = session.getAuthenticationSelector(); if (selector != null) { RemoteRepository repo = RepositoryUtils.toRepo(repository); org.eclipse.aether.repository.Authentication auth = selector.getAuthentication(repo); if (auth != null) { repo = new RemoteRepository.Builder(repo).setAuthentication(auth).build(); AuthenticationContext authCtx = AuthenticationContext.forRepository(session, repo); Authentication result = new Authentication(authCtx.get(AuthenticationContext.USERNAME), authCtx.get(AuthenticationContext.PASSWORD)); result.setPrivateKey(authCtx.get(AuthenticationContext.PRIVATE_KEY_PATH)); result.setPassphrase(authCtx.get(AuthenticationContext.PRIVATE_KEY_PASSPHRASE)); authCtx.close(); return result; } } } return null; } public void injectAuthentication(RepositorySystemSession session, List<ArtifactRepository> repositories) { if (repositories != null && session != null) { for (ArtifactRepository repository : repositories) { repository.setAuthentication(getAuthentication(session, repository)); } } } private Proxy getProxy(RepositorySystemSession session, ArtifactRepository repository) { if (session != null) { ProxySelector selector = session.getProxySelector(); if (selector != null) { RemoteRepository repo = RepositoryUtils.toRepo(repository); org.eclipse.aether.repository.Proxy proxy = selector.getProxy(repo); if (proxy != null) { Proxy p = new Proxy(); p.setHost(proxy.getHost()); p.setProtocol(proxy.getType()); p.setPort(proxy.getPort()); if (proxy.getAuthentication() != null) { repo = new RemoteRepository.Builder(repo).setProxy(proxy).build(); AuthenticationContext authCtx = AuthenticationContext.forProxy(session, repo); p.setUserName(authCtx.get(AuthenticationContext.USERNAME)); p.setPassword(authCtx.get(AuthenticationContext.PASSWORD)); p.setNtlmDomain(authCtx.get(AuthenticationContext.NTLM_DOMAIN)); p.setNtlmHost(authCtx.get(AuthenticationContext.NTLM_WORKSTATION)); authCtx.close(); } return p; } } } return null; } public void injectProxy(RepositorySystemSession session, List<ArtifactRepository> repositories) { if (repositories != null && session != null) { for (ArtifactRepository repository : repositories) { repository.setProxy(getProxy(session, repository)); } } } private ArtifactRepositoryLayout getLayout(String id) { ArtifactRepositoryLayout layout = layouts.get(id); return layout; } // // Taken from LegacyRepositorySystem // public static org.apache.maven.model.Repository fromSettingsRepository( org.apache.maven.settings.Repository settingsRepository) { org.apache.maven.model.Repository modelRepository = new org.apache.maven.model.Repository(); modelRepository.setId(settingsRepository.getId()); modelRepository.setLayout(settingsRepository.getLayout()); modelRepository.setName(settingsRepository.getName()); modelRepository.setUrl(settingsRepository.getUrl()); modelRepository.setReleases(fromSettingsRepositoryPolicy(settingsRepository.getReleases())); modelRepository.setSnapshots(fromSettingsRepositoryPolicy(settingsRepository.getSnapshots())); return modelRepository; } public static org.apache.maven.model.RepositoryPolicy fromSettingsRepositoryPolicy( org.apache.maven.settings.RepositoryPolicy settingsRepositoryPolicy) { org.apache.maven.model.RepositoryPolicy modelRepositoryPolicy = new org.apache.maven.model.RepositoryPolicy(); if (settingsRepositoryPolicy != null) { modelRepositoryPolicy.setEnabled(settingsRepositoryPolicy.isEnabled()); modelRepositoryPolicy.setUpdatePolicy(settingsRepositoryPolicy.getUpdatePolicy()); modelRepositoryPolicy.setChecksumPolicy(settingsRepositoryPolicy.getChecksumPolicy()); } return modelRepositoryPolicy; } public static ArtifactRepository buildArtifactRepository(org.apache.maven.settings.Repository repo) throws InvalidRepositoryException { return buildArtifactRepository(fromSettingsRepository(repo)); } public static ArtifactRepository buildArtifactRepository(org.apache.maven.model.Repository repo) throws InvalidRepositoryException { if (repo != null) { String id = repo.getId(); if (StringUtils.isEmpty(id)) { throw new InvalidRepositoryException("Repository identifier missing", ""); } String url = repo.getUrl(); if (StringUtils.isEmpty(url)) { throw new InvalidRepositoryException("URL missing for repository " + id, id); } ArtifactRepositoryPolicy snapshots = buildArtifactRepositoryPolicy(repo.getSnapshots()); ArtifactRepositoryPolicy releases = buildArtifactRepositoryPolicy(repo.getReleases()); ArtifactRepositoryLayout layout = new DefaultRepositoryLayout(); return createArtifactRepository(id, url, layout, snapshots, releases); } else { return null; } } public static ArtifactRepositoryPolicy buildArtifactRepositoryPolicy( org.apache.maven.model.RepositoryPolicy policy) { boolean enabled = true; String updatePolicy = null; String checksumPolicy = null; if (policy != null) { enabled = policy.isEnabled(); if (policy.getUpdatePolicy() != null) { updatePolicy = policy.getUpdatePolicy(); } if (policy.getChecksumPolicy() != null) { checksumPolicy = policy.getChecksumPolicy(); } } return new ArtifactRepositoryPolicy(enabled, updatePolicy, checksumPolicy); } public ArtifactRepository createArtifactRepository(String id, String url, String layoutId, ArtifactRepositoryPolicy snapshots, ArtifactRepositoryPolicy releases) throws Exception { ArtifactRepositoryLayout layout = layouts.get(layoutId); checkLayout(id, layoutId, layout); return createArtifactRepository(id, url, layout, snapshots, releases); } private void checkLayout(String repositoryId, String layoutId, ArtifactRepositoryLayout layout) throws Exception { if (layout == null) { throw new Exception(String.format("Cannot find ArtifactRepositoryLayout instance for: %s %s", layoutId, repositoryId)); } } public static ArtifactRepository createArtifactRepository(String id, String url, ArtifactRepositoryLayout repositoryLayout, ArtifactRepositoryPolicy snapshots, ArtifactRepositoryPolicy releases) { if (snapshots == null) { snapshots = new ArtifactRepositoryPolicy(); } if (releases == null) { releases = new ArtifactRepositoryPolicy(); } ArtifactRepository repository; if (repositoryLayout instanceof ArtifactRepositoryLayout2) { repository = ((ArtifactRepositoryLayout2) repositoryLayout).newMavenArtifactRepository(id, url, snapshots, releases); } else { repository = new MavenArtifactRepository(id, url, repositoryLayout, snapshots, releases); } return repository; } // ArtifactFactory private Artifact createArtifactX(String groupId, String artifactId, String version, String scope, String type) { return createArtifactX(groupId, artifactId, version, scope, type, null, null); } private Artifact createDependencyArtifactX(String groupId, String artifactId, VersionRange versionRange, String type, String classifier, String scope, boolean optional) { return createArtifactX(groupId, artifactId, versionRange, type, classifier, scope, null, optional); } private Artifact createProjectArtifactX(String groupId, String artifactId, String version) { return createProjectArtifactX(groupId, artifactId, version, null); } private Artifact createParentArtifactX(String groupId, String artifactId, String version) { return createProjectArtifactX(groupId, artifactId, version); } private Artifact createPluginArtifactX(String groupId, String artifactId, VersionRange versionRange) { return createArtifactX(groupId, artifactId, versionRange, "maven-plugin", null, Artifact.SCOPE_RUNTIME, null); } private Artifact createProjectArtifactX(String groupId, String artifactId, String version, String scope) { return createArtifactX(groupId, artifactId, version, scope, "pom"); } private Artifact createExtensionArtifactX(String groupId, String artifactId, VersionRange versionRange) { return createArtifactX(groupId, artifactId, versionRange, "jar", null, Artifact.SCOPE_RUNTIME, null); } private Artifact createArtifactX(String groupId, String artifactId, String version, String scope, String type, String classifier, String inheritedScope) { VersionRange versionRange = null; if (version != null) { versionRange = VersionRange.createFromVersion(version); } return createArtifactX(groupId, artifactId, versionRange, type, classifier, scope, inheritedScope); } private Artifact createArtifactX(String groupId, String artifactId, VersionRange versionRange, String type, String classifier, String scope, String inheritedScope) { return createArtifactX(groupId, artifactId, versionRange, type, classifier, scope, inheritedScope, false); } @SuppressWarnings("checkstyle:parameternumber") private Artifact createArtifactX(String groupId, String artifactId, VersionRange versionRange, String type, String classifier, String scope, String inheritedScope, boolean optional) { String desiredScope = Artifact.SCOPE_RUNTIME; if (inheritedScope == null) { desiredScope = scope; } else if (Artifact.SCOPE_TEST.equals(scope) || Artifact.SCOPE_PROVIDED.equals(scope)) { return null; } else if (Artifact.SCOPE_COMPILE.equals(scope) && Artifact.SCOPE_COMPILE.equals(inheritedScope)) { // added to retain compile artifactScope. Remove if you want compile inherited as runtime desiredScope = Artifact.SCOPE_COMPILE; } if (Artifact.SCOPE_TEST.equals(inheritedScope)) { desiredScope = Artifact.SCOPE_TEST; } if (Artifact.SCOPE_PROVIDED.equals(inheritedScope)) { desiredScope = Artifact.SCOPE_PROVIDED; } if (Artifact.SCOPE_SYSTEM.equals(scope)) { // system scopes come through unchanged... desiredScope = Artifact.SCOPE_SYSTEM; } ArtifactHandler handler = artifactHandlerManager.getArtifactHandler(type); return new DefaultArtifact(groupId, artifactId, versionRange, desiredScope, type, classifier, handler, optional); } // // Code taken from LegacyRepositorySystem // public ArtifactRepository createDefaultRemoteRepository(MavenExecutionRequest request) throws Exception { return createRepository(RepositorySystem.DEFAULT_REMOTE_REPO_URL, RepositorySystem.DEFAULT_REMOTE_REPO_ID, true, ArtifactRepositoryPolicy.UPDATE_POLICY_DAILY, false, ArtifactRepositoryPolicy.UPDATE_POLICY_DAILY, ArtifactRepositoryPolicy.CHECKSUM_POLICY_WARN); } public ArtifactRepository createRepository(String url, String repositoryId, boolean releases, String releaseUpdates, boolean snapshots, String snapshotUpdates, String checksumPolicy) throws Exception { ArtifactRepositoryPolicy snapshotsPolicy = new ArtifactRepositoryPolicy(snapshots, snapshotUpdates, checksumPolicy); ArtifactRepositoryPolicy releasesPolicy = new ArtifactRepositoryPolicy(releases, releaseUpdates, checksumPolicy); return createArtifactRepository(repositoryId, url, "default", snapshotsPolicy, releasesPolicy); } public Set<String> getRepoIds(List<ArtifactRepository> repositories) { Set<String> repoIds = new HashSet<>(); if (repositories != null) { for (ArtifactRepository repository : repositories) { repoIds.add(repository.getId()); } } return repoIds; } /** * Source from org.apache.maven.repository.legacy.LegacyRepositorySystem#getEffectiveRepositories * * @param repositories * @return * @since 3.6.1 */ public List<ArtifactRepository> getEffectiveRepositories(List<ArtifactRepository> repositories) { if (repositories == null) { return null; } Map<String, List<ArtifactRepository>> reposByKey = new LinkedHashMap<>(); for (ArtifactRepository repository : repositories) { String key = repository.getId(); List<ArtifactRepository> aliasedRepos = reposByKey.get(key); if (aliasedRepos == null) { aliasedRepos = new ArrayList<>(); reposByKey.put(key, aliasedRepos); } aliasedRepos.add(repository); } List<ArtifactRepository> effectiveRepositories = new ArrayList<>(); for (List<ArtifactRepository> aliasedRepos : reposByKey.values()) { List<ArtifactRepository> mirroredRepos = new ArrayList<>(); List<ArtifactRepositoryPolicy> releasePolicies = new ArrayList<>(aliasedRepos.size()); for (ArtifactRepository aliasedRepo : aliasedRepos) { releasePolicies.add(aliasedRepo.getReleases()); mirroredRepos.addAll(aliasedRepo.getMirroredRepositories()); } ArtifactRepositoryPolicy releasePolicy = getEffectivePolicy(releasePolicies); List<ArtifactRepositoryPolicy> snapshotPolicies = new ArrayList<>(aliasedRepos.size()); for (ArtifactRepository aliasedRepo : aliasedRepos) { snapshotPolicies.add(aliasedRepo.getSnapshots()); } ArtifactRepositoryPolicy snapshotPolicy = getEffectivePolicy(snapshotPolicies); ArtifactRepository aliasedRepo = aliasedRepos.get(0); ArtifactRepository effectiveRepository = createArtifactRepository(aliasedRepo.getId(), aliasedRepo.getUrl(), aliasedRepo.getLayout(), snapshotPolicy, releasePolicy); effectiveRepository.setAuthentication(aliasedRepo.getAuthentication()); effectiveRepository.setProxy(aliasedRepo.getProxy()); effectiveRepository.setMirroredRepositories(mirroredRepos); effectiveRepositories.add(effectiveRepository); } return effectiveRepositories; } private ArtifactRepositoryPolicy getEffectivePolicy(Collection<ArtifactRepositoryPolicy> policies) { ArtifactRepositoryPolicy effectivePolicy = null; for (ArtifactRepositoryPolicy policy : policies) { if (effectivePolicy == null) { effectivePolicy = new ArtifactRepositoryPolicy(policy); } else { effectivePolicy.merge(policy); } } return effectivePolicy; } public ArtifactRepository createLocalRepository(MavenExecutionRequest request, File localRepository) throws Exception { return createRepository("file://" + localRepository.toURI().getRawPath(), RepositorySystem.DEFAULT_LOCAL_REPO_ID, true, ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS, true, ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS, ArtifactRepositoryPolicy.CHECKSUM_POLICY_IGNORE); } private static final String WILDCARD = "*"; private static final String EXTERNAL_WILDCARD = "external:*"; public static Mirror getMirror(ArtifactRepository repository, List<Mirror> mirrors) { String repoId = repository.getId(); if (repoId != null && mirrors != null) { for (Mirror mirror : mirrors) { if (repoId.equals(mirror.getMirrorOf()) && matchesLayout(repository, mirror)) { return mirror; } } for (Mirror mirror : mirrors) { if (matchPattern(repository, mirror.getMirrorOf()) && matchesLayout(repository, mirror)) { return mirror; } } } return null; } /** * This method checks if the pattern matches the originalRepository. Valid patterns: * = everything external:* = * everything not on the localhost and not file based. repo,repo1 = repo or repo1 *,!repo1 = everything except repo1 * * @param originalRepository to compare for a match. * @param pattern used for match. Currently only '*' is supported. * @return true if the repository is a match to this pattern. */ static boolean matchPattern(ArtifactRepository originalRepository, String pattern) { boolean result = false; String originalId = originalRepository.getId(); // simple checks first to short circuit processing below. if (WILDCARD.equals(pattern) || pattern.equals(originalId)) { result = true; } else { // process the list String[] repos = pattern.split(","); for (String repo : repos) { // see if this is a negative match if (repo.length() > 1 && repo.startsWith("!")) { if (repo.substring(1).equals(originalId)) { // explicitly exclude. Set result and stop processing. result = false; break; } } // check for exact match else if (repo.equals(originalId)) { result = true; break; } // check for external:* else if (EXTERNAL_WILDCARD.equals(repo) && isExternalRepo(originalRepository)) { result = true; // don't stop processing in case a future segment explicitly excludes this repo } else if (WILDCARD.equals(repo)) { result = true; // don't stop processing in case a future segment explicitly excludes this repo } } } return result; } /** * Checks the URL to see if this repository refers to an external repository * * @param originalRepository * @return true if external. */ static boolean isExternalRepo(ArtifactRepository originalRepository) { try { URL url = new URL(originalRepository.getUrl()); return !(url.getHost().equals("localhost") || url.getHost().equals("127.0.0.1") || url.getProtocol().equals("file")); } catch (MalformedURLException e) { // bad url just skip it here. It should have been validated already, but the wagon lookup will deal with it return false; } } static boolean matchesLayout(ArtifactRepository repository, Mirror mirror) { return matchesLayout(RepositoryUtils.getLayout(repository), mirror.getMirrorOfLayouts()); } /** * Checks whether the layouts configured for a mirror match with the layout of the repository. * * @param repoLayout The layout of the repository, may be {@code null}. * @param mirrorLayout The layouts supported by the mirror, may be {@code null}. * @return {@code true} if the layouts associated with the mirror match the layout of the original repository, * {@code false} otherwise. */ static boolean matchesLayout(String repoLayout, String mirrorLayout) { boolean result = false; // simple checks first to short circuit processing below. if (StringUtils.isEmpty(mirrorLayout) || WILDCARD.equals(mirrorLayout)) { result = true; } else if (mirrorLayout.equals(repoLayout)) { result = true; } else { // process the list String[] layouts = mirrorLayout.split(","); for (String layout : layouts) { // see if this is a negative match if (layout.length() > 1 && layout.startsWith("!")) { if (layout.substring(1).equals(repoLayout)) { // explicitly exclude. Set result and stop processing. result = false; break; } } // check for exact match else if (layout.equals(repoLayout)) { result = true; break; } else if (WILDCARD.equals(layout)) { result = true; // don't stop processing in case a future segment explicitly excludes this repo } } } return result; } }