package org.apache.maven.execution;
/*
* 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.util.HashSet;
import java.util.List;
import java.util.Set;
import org.apache.maven.artifact.InvalidRepositoryException;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.repository.RepositorySystem;
import org.apache.maven.settings.Mirror;
import org.apache.maven.settings.Proxy;
import org.apache.maven.settings.Server;
import org.apache.maven.settings.Settings;
import org.apache.maven.settings.SettingsUtils;
import org.codehaus.plexus.component.annotations.Component;
import org.codehaus.plexus.component.annotations.Requirement;
import org.codehaus.plexus.util.StringUtils;
@Component( role = MavenExecutionRequestPopulator.class )
public class DefaultMavenExecutionRequestPopulator
implements MavenExecutionRequestPopulator
{
@Requirement
private RepositorySystem repositorySystem;
public MavenExecutionRequest populateFromSettings( MavenExecutionRequest request, Settings settings )
throws MavenExecutionRequestPopulationException
{
if ( settings == null )
{
return request;
}
request.setOffline( settings.isOffline() );
request.setInteractiveMode( settings.isInteractiveMode() );
request.setPluginGroups( settings.getPluginGroups() );
request.setLocalRepositoryPath( settings.getLocalRepository() );
for ( Server server : settings.getServers() )
{
server = server.clone();
request.addServer( server );
}
// <proxies>
// <proxy>
// <active>true</active>
// <protocol>http</protocol>
// <host>proxy.somewhere.com</host>
// <port>8080</port>
// <username>proxyuser</username>
// <password>somepassword</password>
// <nonProxyHosts>www.google.com|*.somewhere.com</nonProxyHosts>
// </proxy>
// </proxies>
for ( Proxy proxy : settings.getProxies() )
{
if ( !proxy.isActive() )
{
continue;
}
proxy = proxy.clone();
request.addProxy( proxy );
}
// <mirrors>
// <mirror>
// <id>nexus</id>
// <mirrorOf>*</mirrorOf>
// <url>http://repository.sonatype.org/content/groups/public</url>
// </mirror>
// </mirrors>
for ( Mirror mirror : settings.getMirrors() )
{
mirror = mirror.clone();
request.addMirror( mirror );
}
request.setActiveProfiles( settings.getActiveProfiles() );
for ( org.apache.maven.settings.Profile rawProfile : settings.getProfiles() )
{
request.addProfile( SettingsUtils.convertFromSettingsProfile( rawProfile ) );
}
return request;
}
private void populateDefaultPluginGroups( MavenExecutionRequest request )
{
request.addPluginGroup( "org.apache.maven.plugins" );
request.addPluginGroup( "org.codehaus.mojo" );
}
private void injectDefaultRepositories( MavenExecutionRequest request )
throws MavenExecutionRequestPopulationException
{
Set<String> definedRepositories = getRepoIds( request.getRemoteRepositories() );
if ( !definedRepositories.contains( RepositorySystem.DEFAULT_REMOTE_REPO_ID ) )
{
try
{
request.addRemoteRepository( repositorySystem.createDefaultRemoteRepository() );
}
catch ( InvalidRepositoryException e )
{
throw new MavenExecutionRequestPopulationException( "Cannot create default remote repository.", e );
}
}
}
private void injectDefaultPluginRepositories( MavenExecutionRequest request )
throws MavenExecutionRequestPopulationException
{
Set<String> definedRepositories = getRepoIds( request.getPluginArtifactRepositories() );
if ( !definedRepositories.contains( RepositorySystem.DEFAULT_REMOTE_REPO_ID ) )
{
try
{
request.addPluginArtifactRepository( repositorySystem.createDefaultRemoteRepository() );
}
catch ( InvalidRepositoryException e )
{
throw new MavenExecutionRequestPopulationException( "Cannot create default remote repository.", e );
}
}
}
private 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;
}
private void processRepositoriesInSettings( MavenExecutionRequest request )
throws MavenExecutionRequestPopulationException
{
repositorySystem.injectMirror( request.getRemoteRepositories(), request.getMirrors() );
repositorySystem.injectProxy( request.getRemoteRepositories(), request.getProxies() );
repositorySystem.injectAuthentication( request.getRemoteRepositories(), request.getServers() );
request.setRemoteRepositories( repositorySystem.getEffectiveRepositories( request.getRemoteRepositories() ) );
repositorySystem.injectMirror( request.getPluginArtifactRepositories(), request.getMirrors() );
repositorySystem.injectProxy( request.getPluginArtifactRepositories(), request.getProxies() );
repositorySystem.injectAuthentication( request.getPluginArtifactRepositories(), request.getServers() );
request.setPluginArtifactRepositories( repositorySystem.getEffectiveRepositories( request.getPluginArtifactRepositories() ) );
}
private void localRepository( MavenExecutionRequest request )
throws MavenExecutionRequestPopulationException
{
// ------------------------------------------------------------------------
// Local Repository
//
// 1. Use a value has been passed in via the configuration
// 2. Use value in the resultant settings
// 3. Use default value
// ------------------------------------------------------------------------
if ( request.getLocalRepository() == null )
{
request.setLocalRepository( createLocalRepository( request ) );
}
if ( request.getLocalRepositoryPath() == null )
{
request.setLocalRepositoryPath( new File( request.getLocalRepository().getBasedir() ).getAbsoluteFile() );
}
}
// ------------------------------------------------------------------------
// Artifact Transfer Mechanism
// ------------------------------------------------------------------------
public ArtifactRepository createLocalRepository( MavenExecutionRequest request )
throws MavenExecutionRequestPopulationException
{
String localRepositoryPath = null;
if ( request.getLocalRepositoryPath() != null )
{
localRepositoryPath = request.getLocalRepositoryPath().getAbsolutePath();
}
if ( StringUtils.isEmpty( localRepositoryPath ) )
{
localRepositoryPath = RepositorySystem.defaultUserLocalRepository.getAbsolutePath();
}
try
{
return repositorySystem.createLocalRepository( new File( localRepositoryPath ) );
}
catch ( InvalidRepositoryException e )
{
throw new MavenExecutionRequestPopulationException( "Cannot create local repository.", e );
}
}
private void baseDirectory( MavenExecutionRequest request )
{
if ( request.getBaseDirectory() == null )
{
if ( request.getPom() != null )
{
request.setBaseDirectory( request.getPom().getAbsoluteFile().getParentFile() );
}
}
}
public MavenExecutionRequest populateDefaults( MavenExecutionRequest request )
throws MavenExecutionRequestPopulationException
{
baseDirectory( request );
localRepository( request );
populateDefaultPluginGroups( request );
injectDefaultRepositories( request );
injectDefaultPluginRepositories( request );
processRepositoriesInSettings( request );
return request;
}
}