diff options
Diffstat (limited to 'framework/src/maven/apache-maven-3.3.3/maven-core/src/main/java/org/apache/maven/bridge/MavenRepositorySystem.java')
| -rw-r--r-- | framework/src/maven/apache-maven-3.3.3/maven-core/src/main/java/org/apache/maven/bridge/MavenRepositorySystem.java | 785 |
1 files changed, 785 insertions, 0 deletions
diff --git a/framework/src/maven/apache-maven-3.3.3/maven-core/src/main/java/org/apache/maven/bridge/MavenRepositorySystem.java b/framework/src/maven/apache-maven-3.3.3/maven-core/src/main/java/org/apache/maven/bridge/MavenRepositorySystem.java new file mode 100644 index 00000000..f33bc328 --- /dev/null +++ b/framework/src/maven/apache-maven-3.3.3/maven-core/src/main/java/org/apache/maven/bridge/MavenRepositorySystem.java @@ -0,0 +1,785 @@ +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.Collections; +import java.util.HashSet; +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.ExcludesArtifactFilter; +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.Exclusion; +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 XcreateArtifact( groupId, artifactId, version, scope, type ); + } + + // DefaultProjectBuilder + public Artifact createProjectArtifact( String groupId, String artifactId, String metaVersionId ) + { + return XcreateProjectArtifact( 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 = + XcreateDependencyArtifact( 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() ) + { + List<String> exclusions = new ArrayList<String>(); + + for ( Exclusion exclusion : d.getExclusions() ) + { + exclusions.add( exclusion.getGroupId() + ':' + exclusion.getArtifactId() ); + } + + artifact.setDependencyFilter( new ExcludesArtifactFilter( exclusions ) ); + } + + 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 XcreateExtensionArtifact( groupId, artifactId, versionRange ); + } + + // DefaultProjectBuilder + public Artifact createParentArtifact( String groupId, String artifactId, String version ) + { + return XcreateParentArtifact( 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 XcreatePluginArtifact( 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 XcreateArtifact( String groupId, String artifactId, String version, String scope, String type ) + { + return XcreateArtifact( groupId, artifactId, version, scope, type, null, null ); + } + + private Artifact XcreateDependencyArtifact( String groupId, String artifactId, VersionRange versionRange, + String type, String classifier, String scope, boolean optional ) + { + return XcreateArtifact( groupId, artifactId, versionRange, type, classifier, scope, null, optional ); + } + + private Artifact XcreateProjectArtifact( String groupId, String artifactId, String version ) + { + return XcreateProjectArtifact( groupId, artifactId, version, null ); + } + + private Artifact XcreateParentArtifact( String groupId, String artifactId, String version ) + { + return XcreateProjectArtifact( groupId, artifactId, version ); + } + + private Artifact XcreatePluginArtifact( String groupId, String artifactId, VersionRange versionRange ) + { + return XcreateArtifact( groupId, artifactId, versionRange, "maven-plugin", null, Artifact.SCOPE_RUNTIME, null ); + } + + private Artifact XcreateProjectArtifact( String groupId, String artifactId, String version, String scope ) + { + return XcreateArtifact( groupId, artifactId, version, scope, "pom" ); + } + + private Artifact XcreateExtensionArtifact( String groupId, String artifactId, VersionRange versionRange ) + { + return XcreateArtifact( groupId, artifactId, versionRange, "jar", null, Artifact.SCOPE_RUNTIME, null ); + } + + private Artifact XcreateArtifact( 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 XcreateArtifact( groupId, artifactId, versionRange, type, classifier, scope, inheritedScope ); + } + + private Artifact XcreateArtifact( String groupId, String artifactId, VersionRange versionRange, String type, + String classifier, String scope, String inheritedScope ) + { + return XcreateArtifact( groupId, artifactId, versionRange, type, classifier, scope, inheritedScope, false ); + } + + private Artifact XcreateArtifact( 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<String>(); + + if ( repositories != null ) + { + for ( ArtifactRepository repository : repositories ) + { + repoIds.add( repository.getId() ); + } + } + + return repoIds; + } + + + 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; + } +} |