| package org.apache.maven.archetype.source; |
| |
| /* |
| * 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.io.IOException; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.apache.maven.archetype.catalog.Archetype; |
| import org.apache.maven.archetype.catalog.ArchetypeCatalog; |
| import org.apache.maven.artifact.repository.ArtifactRepository; |
| import org.apache.maven.execution.MavenExecutionRequest; |
| import org.apache.maven.execution.MavenSession; |
| import org.apache.maven.plugin.LegacySupport; |
| import org.apache.maven.project.ProjectBuildingRequest; |
| import org.apache.maven.settings.Mirror; |
| import org.apache.maven.settings.Proxy; |
| import org.apache.maven.settings.Server; |
| import org.apache.maven.settings.crypto.DefaultSettingsDecryptionRequest; |
| import org.apache.maven.settings.crypto.SettingsDecrypter; |
| import org.apache.maven.settings.crypto.SettingsDecryptionResult; |
| import org.apache.maven.wagon.UnsupportedProtocolException; |
| import org.apache.maven.wagon.Wagon; |
| import org.apache.maven.wagon.WagonException; |
| import org.apache.maven.wagon.authentication.AuthenticationInfo; |
| import org.apache.maven.wagon.proxy.ProxyInfo; |
| import org.apache.maven.wagon.repository.Repository; |
| import org.codehaus.plexus.component.annotations.Component; |
| import org.codehaus.plexus.component.annotations.Requirement; |
| import org.codehaus.plexus.util.ReaderFactory; |
| import org.codehaus.plexus.util.StringUtils; |
| |
| /** |
| * @author Jason van Zyl |
| */ |
| @Component( role = ArchetypeDataSource.class, hint = "remote-catalog" ) |
| public class RemoteCatalogArchetypeDataSource extends CatalogArchetypeDataSource implements ArchetypeDataSource |
| { |
| @Requirement |
| private Map<String, Wagon> wagons; |
| |
| @Requirement |
| private LegacySupport legacySupport; |
| |
| @Requirement |
| private SettingsDecrypter settingsDecrypter; |
| |
| // Should be used for mirror/proxy/authentication |
| // available since M3.2.3 |
| // @Requirement |
| // private MavenRepositorySystem; |
| |
| /** |
| * Id of the repository used to download catalog file. Proxy or authentication info can |
| * be setup in settings.xml. |
| */ |
| public static final String ARCHETYPE_REPOSITORY_ID = "archetype"; |
| |
| public static final String CENTRAL_REPOSITORY_ID = "central"; |
| |
| @Override |
| public ArchetypeCatalog getArchetypeCatalog( ProjectBuildingRequest buildingRequest ) |
| throws ArchetypeDataSourceException |
| { |
| // With M3 artifactRepositories are already injected with their mirror, including the new id |
| // First look for mirrorId of both 'central' and 'archetype' |
| final String archetypeRepoId; |
| Mirror archetypeMirror = getMirror( ARCHETYPE_REPOSITORY_ID ); |
| if ( archetypeMirror != null ) |
| { |
| archetypeRepoId = archetypeMirror.getId(); |
| } |
| else |
| { |
| archetypeRepoId = ARCHETYPE_REPOSITORY_ID; |
| } |
| |
| final String centralRepoId; |
| Mirror centralMirror = getMirror( CENTRAL_REPOSITORY_ID ); |
| if ( centralMirror != null ) |
| { |
| centralRepoId = centralMirror.getId(); |
| } |
| else |
| { |
| centralRepoId = CENTRAL_REPOSITORY_ID; |
| } |
| |
| ArtifactRepository centralRepository = null; |
| ArtifactRepository archetypeRepository = null; |
| for ( ArtifactRepository remoteRepository : buildingRequest.getRemoteRepositories() ) |
| { |
| if ( archetypeRepoId.equals( remoteRepository.getId() ) ) |
| { |
| archetypeRepository = remoteRepository; |
| break; |
| } |
| else if ( centralRepoId.equals( remoteRepository.getId() ) ) |
| { |
| centralRepository = remoteRepository; |
| } |
| } |
| |
| if ( archetypeRepository == null ) |
| { |
| archetypeRepository = centralRepository; |
| } |
| |
| try |
| { |
| return downloadCatalog( archetypeRepository ); |
| } |
| catch ( IOException e ) |
| { |
| throw new ArchetypeDataSourceException( e ); |
| } |
| catch ( WagonException e ) |
| { |
| throw new ArchetypeDataSourceException( e ); |
| } |
| } |
| |
| @Override |
| public void updateCatalog( ProjectBuildingRequest buildingRequest, Archetype archetype ) |
| throws ArchetypeDataSourceException |
| { |
| throw new ArchetypeDataSourceException( "Not supported yet." ); |
| } |
| |
| private ArchetypeCatalog downloadCatalog( ArtifactRepository repository ) |
| throws WagonException, IOException, ArchetypeDataSourceException |
| { |
| getLogger().debug( "Searching for remote catalog: " + repository.getUrl() + "/" + ARCHETYPE_CATALOG_FILENAME ); |
| |
| // We use wagon to take advantage of a Proxy that has already been setup in a Maven environment. |
| Repository wagonRepository = new Repository( repository.getId(), repository.getUrl() ); |
| |
| AuthenticationInfo authInfo = getAuthenticationInfo( wagonRepository.getId() ); |
| ProxyInfo proxyInfo = getProxy( wagonRepository.getProtocol() ); |
| |
| Wagon wagon = getWagon( wagonRepository ); |
| |
| File catalog = File.createTempFile( "archetype-catalog", ".xml" ); |
| try |
| { |
| wagon.connect( wagonRepository, authInfo, proxyInfo ); |
| wagon.get( ARCHETYPE_CATALOG_FILENAME, catalog ); |
| |
| return readCatalog( ReaderFactory.newXmlReader( catalog ) ); |
| } |
| finally |
| { |
| disconnectWagon( wagon ); |
| catalog.delete(); |
| } |
| } |
| |
| private void disconnectWagon( Wagon wagon ) |
| { |
| try |
| { |
| wagon.disconnect(); |
| } |
| catch ( Exception e ) |
| { |
| getLogger().warn( "Problem disconnecting from wagon - ignoring: " + e.getMessage() ); |
| } |
| } |
| |
| // |
| |
| private Wagon getWagon( Repository repository ) |
| throws UnsupportedProtocolException |
| { |
| return getWagon( repository.getProtocol() ); |
| } |
| |
| private Wagon getWagon( String protocol ) |
| throws UnsupportedProtocolException |
| { |
| if ( protocol == null ) |
| { |
| throw new UnsupportedProtocolException( "Unspecified protocol" ); |
| } |
| |
| String hint = protocol.toLowerCase( java.util.Locale.ENGLISH ); |
| |
| Wagon wagon = wagons.get( hint ); |
| if ( wagon == null ) |
| { |
| throw new UnsupportedProtocolException( "Cannot find wagon which supports the requested protocol: " |
| + protocol ); |
| } |
| |
| return wagon; |
| } |
| |
| private AuthenticationInfo getAuthenticationInfo( String id ) |
| { |
| MavenSession session = legacySupport.getSession(); |
| |
| if ( session != null && id != null ) |
| { |
| MavenExecutionRequest request = session.getRequest(); |
| |
| if ( request != null ) |
| { |
| List<Server> servers = request.getServers(); |
| |
| if ( servers != null ) |
| { |
| for ( Server server : servers ) |
| { |
| if ( id.equalsIgnoreCase( server.getId() ) ) |
| { |
| SettingsDecryptionResult result = |
| settingsDecrypter.decrypt( new DefaultSettingsDecryptionRequest( server ) ); |
| server = result.getServer(); |
| |
| AuthenticationInfo authInfo = new AuthenticationInfo(); |
| authInfo.setUserName( server.getUsername() ); |
| authInfo.setPassword( server.getPassword() ); |
| authInfo.setPrivateKey( server.getPrivateKey() ); |
| authInfo.setPassphrase( server.getPassphrase() ); |
| |
| return authInfo; |
| } |
| } |
| } |
| } |
| } |
| |
| // empty one to prevent NPE |
| return new AuthenticationInfo(); |
| } |
| |
| private ProxyInfo getProxy( String protocol ) |
| { |
| MavenSession session = legacySupport.getSession(); |
| |
| if ( session != null && protocol != null ) |
| { |
| MavenExecutionRequest request = session.getRequest(); |
| |
| if ( request != null ) |
| { |
| List<Proxy> proxies = request.getProxies(); |
| |
| if ( proxies != null ) |
| { |
| for ( Proxy proxy : proxies ) |
| { |
| if ( proxy.isActive() && protocol.equalsIgnoreCase( proxy.getProtocol() ) ) |
| { |
| SettingsDecryptionResult result = |
| settingsDecrypter.decrypt( new DefaultSettingsDecryptionRequest( proxy ) ); |
| proxy = result.getProxy(); |
| |
| ProxyInfo proxyInfo = new ProxyInfo(); |
| proxyInfo.setHost( proxy.getHost() ); |
| proxyInfo.setType( proxy.getProtocol() ); |
| proxyInfo.setPort( proxy.getPort() ); |
| proxyInfo.setNonProxyHosts( proxy.getNonProxyHosts() ); |
| proxyInfo.setUserName( proxy.getUsername() ); |
| proxyInfo.setPassword( proxy.getPassword() ); |
| |
| return proxyInfo; |
| } |
| } |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| private Mirror getMirror( String repoId ) |
| { |
| MavenSession session = legacySupport.getSession(); |
| |
| MavenExecutionRequest request = session.getRequest(); |
| |
| if ( request != null ) |
| { |
| return getMirror( repoId, request.getMirrors() ); |
| } |
| |
| return null; |
| } |
| |
| private static final String WILDCARD = "*"; |
| |
| private static final String EXTERNAL_WILDCARD = "external:*"; |
| |
| private Mirror getMirror( String repoId, List<Mirror> mirrors ) |
| { |
| if ( repoId != null && mirrors != null ) |
| { |
| for ( Mirror mirror : mirrors ) |
| { |
| if ( repoId.equals( mirror.getMirrorOf() ) ) |
| { |
| return mirror; |
| } |
| } |
| |
| for ( Mirror mirror : mirrors ) |
| { |
| if ( matchPattern( repoId, mirror.getMirrorOf() ) ) |
| { |
| 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( String originalId, String pattern ) |
| { |
| boolean result = false; |
| |
| // 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 ) ) |
| { |
| 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; |
| } |
| |
| |
| |
| static boolean matchesLayout( ArtifactRepository repository, Mirror mirror ) |
| { |
| return matchesLayout( repository.getLayout().getId(), 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; |
| } |
| } |
