http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/a088cdfc/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntRepoSys.java ---------------------------------------------------------------------- diff --git a/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntRepoSys.java b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntRepoSys.java new file mode 100644 index 0000000..3b158e4 --- /dev/null +++ b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntRepoSys.java @@ -0,0 +1,825 @@ +package org.apache.maven.resolver.internal.ant; + +/* + * 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.BufferedReader; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Properties; +import java.util.concurrent.CopyOnWriteArrayList; + +import org.apache.maven.model.Model; +import org.apache.maven.model.building.DefaultModelBuilderFactory; +import org.apache.maven.model.building.DefaultModelBuildingRequest; +import org.apache.maven.model.building.FileModelSource; +import org.apache.maven.model.building.ModelBuilder; +import org.apache.maven.model.building.ModelBuildingException; +import org.apache.maven.model.building.ModelBuildingRequest; +import org.apache.maven.model.resolution.ModelResolver; +import org.apache.maven.repository.internal.MavenRepositorySystemUtils; +import org.apache.maven.resolver.internal.ant.types.Artifact; +import org.apache.maven.resolver.internal.ant.types.Artifacts; +import org.apache.maven.resolver.internal.ant.types.Authentication; +import org.apache.maven.resolver.internal.ant.types.Dependencies; +import org.apache.maven.resolver.internal.ant.types.Dependency; +import org.apache.maven.resolver.internal.ant.types.DependencyContainer; +import org.apache.maven.resolver.internal.ant.types.Exclusion; +import org.apache.maven.resolver.internal.ant.types.LocalRepository; +import org.apache.maven.resolver.internal.ant.types.Mirror; +import org.apache.maven.resolver.internal.ant.types.Pom; +import org.apache.maven.resolver.internal.ant.types.Proxy; +import org.apache.maven.resolver.internal.ant.types.RemoteRepositories; +import org.apache.maven.resolver.internal.ant.types.RemoteRepository; +import org.apache.maven.settings.Server; +import org.apache.maven.settings.Settings; +import org.apache.maven.settings.building.DefaultSettingsBuilderFactory; +import org.apache.maven.settings.building.DefaultSettingsBuildingRequest; +import org.apache.maven.settings.building.SettingsBuilder; +import org.apache.maven.settings.building.SettingsBuildingException; +import org.apache.maven.settings.crypto.DefaultSettingsDecryptionRequest; +import org.apache.maven.settings.crypto.SettingsDecrypter; +import org.apache.maven.settings.crypto.SettingsDecryptionResult; +import org.apache.tools.ant.BuildException; +import org.apache.tools.ant.Project; +import org.apache.tools.ant.Task; +import org.apache.tools.ant.taskdefs.condition.Os; +import org.apache.tools.ant.types.Reference; +import org.codehaus.plexus.util.xml.Xpp3Dom; +import org.eclipse.aether.ConfigurationProperties; +import org.eclipse.aether.DefaultRepositoryCache; +import org.eclipse.aether.DefaultRepositorySystemSession; +import org.eclipse.aether.RepositorySystem; +import org.eclipse.aether.RepositorySystemSession; +import org.eclipse.aether.artifact.DefaultArtifact; +import org.eclipse.aether.collection.CollectRequest; +import org.eclipse.aether.collection.CollectResult; +import org.eclipse.aether.collection.DependencyCollectionException; +import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory; +import org.eclipse.aether.deployment.DeployRequest; +import org.eclipse.aether.deployment.DeploymentException; +import org.eclipse.aether.impl.DefaultServiceLocator; +import org.eclipse.aether.impl.RemoteRepositoryManager; +import org.eclipse.aether.installation.InstallRequest; +import org.eclipse.aether.installation.InstallationException; +import org.eclipse.aether.repository.AuthenticationSelector; +import org.eclipse.aether.repository.LocalRepositoryManager; +import org.eclipse.aether.repository.MirrorSelector; +import org.eclipse.aether.repository.ProxySelector; +import org.eclipse.aether.spi.connector.RepositoryConnectorFactory; +import org.eclipse.aether.spi.connector.transport.TransporterFactory; +import org.eclipse.aether.spi.log.Logger; +import org.eclipse.aether.transport.classpath.ClasspathTransporterFactory; +import org.eclipse.aether.transport.file.FileTransporterFactory; +import org.eclipse.aether.transport.http.HttpTransporterFactory; +import org.eclipse.aether.util.repository.AuthenticationBuilder; +import org.eclipse.aether.util.repository.ConservativeAuthenticationSelector; +import org.eclipse.aether.util.repository.DefaultAuthenticationSelector; +import org.eclipse.aether.util.repository.DefaultMirrorSelector; +import org.eclipse.aether.util.repository.DefaultProxySelector; + +/** + */ +public class AntRepoSys +{ + + private static final boolean OS_WINDOWS = Os.isFamily( "windows" ); + + private static final ModelBuilder MODEL_BUILDER = new DefaultModelBuilderFactory().newInstance(); + + private static final SettingsBuilder SETTINGS_BUILDER = new DefaultSettingsBuilderFactory().newInstance(); + + private static final SettingsDecrypter SETTINGS_DECRYPTER = new AntSettingsDecryptorFactory().newInstance(); + + private final Project project; + + private final DefaultServiceLocator locator; + + private RepositorySystem repoSys; + + private RemoteRepositoryManager remoteRepoMan; + + private File userSettings; + + private File globalSettings; + + private Settings settings; + + private final List<Mirror> mirrors = new CopyOnWriteArrayList<Mirror>(); + + private final List<Proxy> proxies = new CopyOnWriteArrayList<Proxy>(); + + private final List<Authentication> authentications = new CopyOnWriteArrayList<Authentication>(); + + private LocalRepository localRepository; + + private Pom defaultPom; + + private static <T> boolean eq( T o1, T o2 ) + { + return ( o1 == null ) ? o2 == null : o1.equals( o2 ); + } + + public static synchronized AntRepoSys getInstance( Project project ) + { + Object obj = project.getReference( Names.ID ); + if ( obj instanceof AntRepoSys ) + { + return (AntRepoSys) obj; + } + AntRepoSys instance = new AntRepoSys( project ); + project.addReference( Names.ID, instance ); + instance.initDefaults(); + return instance; + } + + private AntRepoSys( Project project ) + { + this.project = project; + + locator = MavenRepositorySystemUtils.newServiceLocator(); + locator.setErrorHandler( new AntServiceLocatorErrorHandler( project ) ); + locator.setServices( Logger.class, new AntLogger( project ) ); + locator.setServices( ModelBuilder.class, MODEL_BUILDER ); + locator.addService( RepositoryConnectorFactory.class, BasicRepositoryConnectorFactory.class ); + locator.addService( TransporterFactory.class, FileTransporterFactory.class ); + locator.addService( TransporterFactory.class, HttpTransporterFactory.class ); + locator.addService( TransporterFactory.class, ClasspathTransporterFactory.class ); + } + + private void initDefaults() + { + RemoteRepository repo = new RemoteRepository(); + repo.setProject( project ); + repo.setId( "central" ); + repo.setUrl( "http://repo1.maven.org/maven2/"; ); + project.addReference( Names.ID_CENTRAL, repo ); + + repo = new RemoteRepository(); + repo.setProject( project ); + repo.setRefid( new Reference( project, Names.ID_CENTRAL ) ); + RemoteRepositories repos = new RemoteRepositories(); + repos.setProject( project ); + repos.addRemoterepo( repo ); + project.addReference( Names.ID_DEFAULT_REPOS, repos ); + } + + public synchronized RepositorySystem getSystem() + { + if ( repoSys == null ) + { + repoSys = locator.getService( RepositorySystem.class ); + if ( repoSys == null ) + { + throw new BuildException( "The repository system could not be initialized" ); + } + } + return repoSys; + } + + private synchronized RemoteRepositoryManager getRemoteRepoMan() + { + if ( remoteRepoMan == null ) + { + remoteRepoMan = locator.getService( RemoteRepositoryManager.class ); + if ( remoteRepoMan == null ) + { + throw new BuildException( "The repository system could not be initialized" ); + } + } + return remoteRepoMan; + } + + public RepositorySystemSession getSession( Task task, LocalRepository localRepo ) + { + DefaultRepositorySystemSession session = MavenRepositorySystemUtils.newSession(); + + Map<Object, Object> configProps = new LinkedHashMap<Object, Object>(); + configProps.put( ConfigurationProperties.USER_AGENT, getUserAgent() ); + configProps.putAll( (Map<?, ?>) project.getProperties() ); + processServerConfiguration( configProps ); + session.setConfigProperties( configProps ); + + session.setOffline( isOffline() ); + session.setUserProperties( project.getUserProperties() ); + + session.setProxySelector( getProxySelector() ); + session.setMirrorSelector( getMirrorSelector() ); + session.setAuthenticationSelector( getAuthSelector() ); + + session.setCache( new DefaultRepositoryCache() ); + + session.setRepositoryListener( new AntRepositoryListener( task ) ); + session.setTransferListener( new AntTransferListener( task ) ); + + session.setLocalRepositoryManager( getLocalRepoMan( session, localRepo ) ); + + session.setWorkspaceReader( ProjectWorkspaceReader.getInstance() ); + + return session; + } + + private String getUserAgent() + { + StringBuilder buffer = new StringBuilder( 128 ); + + buffer.append( "Apache-Ant/" ).append( project.getProperty( "ant.version" ) ); + buffer.append( " (" ); + buffer.append( "Java " ).append( System.getProperty( "java.version" ) ); + buffer.append( "; " ); + buffer.append( System.getProperty( "os.name" ) ).append( " " ).append( System.getProperty( "os.version" ) ); + buffer.append( ")" ); + buffer.append( " Aether" ); + + return buffer.toString(); + } + + private boolean isOffline() + { + String prop = project.getProperty( Names.PROPERTY_OFFLINE ); + if ( prop != null ) + { + return Boolean.parseBoolean( prop ); + } + return getSettings().isOffline(); + } + + private void processServerConfiguration( Map<Object, Object> configProps ) + { + Settings settings = getSettings(); + for ( Server server : settings.getServers() ) + { + if ( server.getConfiguration() != null ) + { + Xpp3Dom dom = (Xpp3Dom) server.getConfiguration(); + for ( int i = dom.getChildCount() - 1; i >= 0; i-- ) + { + Xpp3Dom child = dom.getChild( i ); + if ( "wagonProvider".equals( child.getName() ) ) + { + dom.removeChild( i ); + } + else if ( "httpHeaders".equals( child.getName() ) ) + { + configProps.put( ConfigurationProperties.HTTP_HEADERS + "." + server.getId(), + getHttpHeaders( child ) ); + } + } + + configProps.put( "aether.connector.wagon.config." + server.getId(), dom ); + } + + configProps.put( "aether.connector.perms.fileMode." + server.getId(), server.getFilePermissions() ); + configProps.put( "aether.connector.perms.dirMode." + server.getId(), server.getDirectoryPermissions() ); + } + } + + private Map<String, String> getHttpHeaders( Xpp3Dom dom ) + { + Map<String, String> headers = new HashMap<String, String>(); + for ( int i = 0; i < dom.getChildCount(); i++ ) + { + Xpp3Dom child = dom.getChild( i ); + Xpp3Dom name = child.getChild( "name" ); + Xpp3Dom value = child.getChild( "value" ); + if ( name != null && name.getValue() != null ) + { + headers.put( name.getValue(), ( value != null ) ? value.getValue() : null ); + } + } + return Collections.unmodifiableMap( headers ); + } + + private File getDefaultLocalRepoDir() + { + String dir = project.getProperty( "maven.repo.local" ); + if ( dir != null ) + { + return project.resolveFile( dir ); + } + + Settings settings = getSettings(); + if ( settings.getLocalRepository() != null ) + { + return new File( settings.getLocalRepository() ); + } + + return new File( new File( project.getProperty( "user.home" ), ".m2" ), "repository" ); + } + + private LocalRepositoryManager getLocalRepoMan( RepositorySystemSession session, LocalRepository localRepo ) + { + if ( localRepo == null ) + { + localRepo = localRepository; + } + + File repoDir; + if ( localRepo != null && localRepo.getDir() != null ) + { + repoDir = localRepo.getDir(); + } + else + { + repoDir = getDefaultLocalRepoDir(); + } + + org.eclipse.aether.repository.LocalRepository repo = + new org.eclipse.aether.repository.LocalRepository( repoDir ); + + return getSystem().newLocalRepositoryManager( session, repo ); + } + + private synchronized Settings getSettings() + { + if ( settings == null ) + { + DefaultSettingsBuildingRequest request = new DefaultSettingsBuildingRequest(); + request.setUserSettingsFile( getUserSettings() ); + request.setGlobalSettingsFile( getGlobalSettings() ); + request.setSystemProperties( getSystemProperties() ); + request.setUserProperties( getUserProperties() ); + + try + { + settings = SETTINGS_BUILDER.build( request ).getEffectiveSettings(); + } + catch ( SettingsBuildingException e ) + { + project.log( "Could not process settings.xml: " + e.getMessage(), e, Project.MSG_WARN ); + } + + SettingsDecryptionResult result = + SETTINGS_DECRYPTER.decrypt( new DefaultSettingsDecryptionRequest( settings ) ); + settings.setServers( result.getServers() ); + settings.setProxies( result.getProxies() ); + } + return settings; + } + + private ProxySelector getProxySelector() + { + DefaultProxySelector selector = new DefaultProxySelector(); + + for ( Proxy proxy : proxies ) + { + selector.add( ConverterUtils.toProxy( proxy ), proxy.getNonProxyHosts() ); + } + + Settings settings = getSettings(); + for ( org.apache.maven.settings.Proxy proxy : settings.getProxies() ) + { + AuthenticationBuilder auth = new AuthenticationBuilder(); + auth.addUsername( proxy.getUsername() ).addPassword( proxy.getPassword() ); + selector.add( new org.eclipse.aether.repository.Proxy( proxy.getProtocol(), proxy.getHost(), + proxy.getPort(), auth.build() ), + proxy.getNonProxyHosts() ); + } + + return selector; + } + + private MirrorSelector getMirrorSelector() + { + DefaultMirrorSelector selector = new DefaultMirrorSelector(); + + for ( Mirror mirror : mirrors ) + { + selector.add( mirror.getId(), mirror.getUrl(), mirror.getType(), false, mirror.getMirrorOf(), null ); + } + + Settings settings = getSettings(); + for ( org.apache.maven.settings.Mirror mirror : settings.getMirrors() ) + { + selector.add( String.valueOf( mirror.getId() ), mirror.getUrl(), mirror.getLayout(), false, + mirror.getMirrorOf(), mirror.getMirrorOfLayouts() ); + } + + return selector; + } + + private AuthenticationSelector getAuthSelector() + { + DefaultAuthenticationSelector selector = new DefaultAuthenticationSelector(); + + Collection<String> ids = new HashSet<String>(); + for ( Authentication auth : authentications ) + { + List<String> servers = auth.getServers(); + if ( !servers.isEmpty() ) + { + org.eclipse.aether.repository.Authentication a = ConverterUtils.toAuthentication( auth ); + for ( String server : servers ) + { + if ( ids.add( server ) ) + { + selector.add( server, a ); + } + } + } + } + + Settings settings = getSettings(); + for ( Server server : settings.getServers() ) + { + AuthenticationBuilder auth = new AuthenticationBuilder(); + auth.addUsername( server.getUsername() ).addPassword( server.getPassword() ); + auth.addPrivateKey( server.getPrivateKey(), server.getPassphrase() ); + selector.add( server.getId(), auth.build() ); + } + + return new ConservativeAuthenticationSelector( selector ); + } + + public synchronized void setUserSettings( File file ) + { + if ( !eq( this.userSettings, file ) ) + { + settings = null; + } + this.userSettings = file; + } + + /* UT */File getUserSettings() + { + if ( userSettings == null ) + { + userSettings = AetherUtils.findUserSettings( project ); + } + return userSettings; + } + + public void setGlobalSettings( File file ) + { + if ( !eq( this.globalSettings, file ) ) + { + settings = null; + } + this.globalSettings = file; + } + + /* UT */File getGlobalSettings() + { + if ( globalSettings == null ) + { + globalSettings = AetherUtils.findGlobalSettings( project ); + } + return globalSettings; + } + + public void addProxy( Proxy proxy ) + { + proxies.add( proxy ); + } + + public void addMirror( Mirror mirror ) + { + mirrors.add( mirror ); + } + + public void addAuthentication( Authentication authentication ) + { + authentications.add( authentication ); + } + + public void setLocalRepository( LocalRepository localRepository ) + { + this.localRepository = localRepository; + } + + public Model loadModel( Task task, File pomFile, boolean local, RemoteRepositories remoteRepositories ) + { + RepositorySystemSession session = getSession( task, null ); + + remoteRepositories = + remoteRepositories == null ? AetherUtils.getDefaultRepositories( project ) : remoteRepositories; + + List<org.eclipse.aether.repository.RemoteRepository> repositories = + ConverterUtils.toRepositories( task.getProject(), session, remoteRepositories, getRemoteRepoMan() ); + + ModelResolver modelResolver = + new AntModelResolver( session, "project", getSystem(), getRemoteRepoMan(), repositories ); + + Settings settings = getSettings(); + + try + { + DefaultModelBuildingRequest request = new DefaultModelBuildingRequest(); + request.setLocationTracking( true ); + request.setProcessPlugins( false ); + if ( local ) + { + request.setPomFile( pomFile ); + request.setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_STRICT ); + } + else + { + request.setModelSource( new FileModelSource( pomFile ) ); + request.setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL ); + } + request.setSystemProperties( getSystemProperties() ); + request.setUserProperties( getUserProperties() ); + request.setProfiles( SettingsUtils.convert( settings.getProfiles() ) ); + request.setActiveProfileIds( settings.getActiveProfiles() ); + request.setModelResolver( modelResolver ); + return MODEL_BUILDER.build( request ).getEffectiveModel(); + } + catch ( ModelBuildingException e ) + { + throw new BuildException( "Could not load POM " + pomFile + ": " + e.getMessage(), e ); + } + } + + private Properties getSystemProperties() + { + Properties props = new Properties(); + getEnvProperties( props ); + props.putAll( System.getProperties() ); + ConverterUtils.addProperties( props, project.getProperties() ); + return props; + } + + private Properties getEnvProperties( Properties props ) + { + if ( props == null ) + { + props = new Properties(); + } + boolean envCaseInsensitive = OS_WINDOWS; + for ( Map.Entry<String, String> entry : System.getenv().entrySet() ) + { + String key = entry.getKey(); + if ( envCaseInsensitive ) + { + key = key.toUpperCase( Locale.ENGLISH ); + } + key = "env." + key; + props.put( key, entry.getValue() ); + } + return props; + } + + private Properties getUserProperties() + { + return ConverterUtils.addProperties( null, project.getUserProperties() ); + } + + /** + * Sets the default POM. + */ + public void setDefaultPom( Pom pom ) + { + this.defaultPom = pom; + } + + /** + * Returns the current default POM. + */ + public Pom getDefaultPom() + { + return defaultPom; + } + + public CollectResult collectDependencies( Task task, Dependencies dependencies, LocalRepository localRepository, + RemoteRepositories remoteRepositories ) + { + RepositorySystemSession session = getSession( task, localRepository ); + + remoteRepositories = + remoteRepositories == null ? AetherUtils.getDefaultRepositories( project ) : remoteRepositories; + + List<org.eclipse.aether.repository.RemoteRepository> repos = + ConverterUtils.toRepositories( project, session, remoteRepositories, getRemoteRepoMan() ); + + CollectRequest collectRequest = new CollectRequest(); + collectRequest.setRequestContext( "project" ); + + for ( org.eclipse.aether.repository.RemoteRepository repo : repos ) + { + task.getProject().log( "Using remote repository " + repo, Project.MSG_VERBOSE ); + collectRequest.addRepository( repo ); + } + + if ( dependencies != null ) + { + populateCollectRequest( collectRequest, task, session, dependencies, Collections.<Exclusion>emptyList() ); + } + + task.getProject().log( "Collecting dependencies", Project.MSG_VERBOSE ); + + CollectResult result; + try + { + result = getSystem().collectDependencies( session, collectRequest ); + } + catch ( DependencyCollectionException e ) + { + throw new BuildException( "Could not collect dependencies: " + e.getMessage(), e ); + } + + return result; + } + + private void populateCollectRequest( CollectRequest collectRequest, Task task, RepositorySystemSession session, + Dependencies dependencies, List<Exclusion> exclusions ) + { + List<Exclusion> globalExclusions = exclusions; + if ( !dependencies.getExclusions().isEmpty() ) + { + globalExclusions = new ArrayList<Exclusion>( exclusions ); + globalExclusions.addAll( dependencies.getExclusions() ); + } + + Collection<String> ids = new HashSet<String>(); + + for ( DependencyContainer container : dependencies.getDependencyContainers() ) + { + if ( container instanceof Dependency ) + { + Dependency dep = (Dependency) container; + ids.add( dep.getVersionlessKey() ); + collectRequest.addDependency( ConverterUtils.toDependency( dep, globalExclusions, session ) ); + } + else + { + populateCollectRequest( collectRequest, task, session, (Dependencies) container, globalExclusions ); + } + } + + if ( dependencies.getPom() != null ) + { + Model model = dependencies.getPom().getModel( task ); + for ( org.apache.maven.model.Dependency dep : model.getDependencies() ) + { + Dependency dependency = new Dependency(); + dependency.setArtifactId( dep.getArtifactId() ); + dependency.setClassifier( dep.getClassifier() ); + dependency.setGroupId( dep.getGroupId() ); + dependency.setScope( dep.getScope() ); + dependency.setType( dep.getType() ); + dependency.setVersion( dep.getVersion() ); + if ( ids.contains( dependency.getVersionlessKey() ) ) + { + project.log( "Ignoring dependency " + dependency.getVersionlessKey() + " from " + model.getId() + + ", already declared locally", Project.MSG_VERBOSE ); + continue; + } + if ( dep.getSystemPath() != null && dep.getSystemPath().length() > 0 ) + { + dependency.setSystemPath( task.getProject().resolveFile( dep.getSystemPath() ) ); + } + for ( org.apache.maven.model.Exclusion exc : dep.getExclusions() ) + { + Exclusion exclusion = new Exclusion(); + exclusion.setGroupId( exc.getGroupId() ); + exclusion.setArtifactId( exc.getArtifactId() ); + exclusion.setClassifier( "*" ); + exclusion.setExtension( "*" ); + dependency.addExclusion( exclusion ); + } + collectRequest.addDependency( ConverterUtils.toDependency( dependency, globalExclusions, session ) ); + } + } + + if ( dependencies.getFile() != null ) + { + List<Dependency> deps = readDependencies( dependencies.getFile() ); + for ( Dependency dependency : deps ) + { + if ( ids.contains( dependency.getVersionlessKey() ) ) + { + project.log( "Ignoring dependency " + dependency.getVersionlessKey() + " from " + + dependencies.getFile() + ", already declared locally", Project.MSG_VERBOSE ); + continue; + } + collectRequest.addDependency( ConverterUtils.toDependency( dependency, globalExclusions, session ) ); + } + } + } + + private List<Dependency> readDependencies( File file ) + { + List<Dependency> dependencies = new ArrayList<Dependency>(); + try + { + BufferedReader reader = new BufferedReader( new InputStreamReader( new FileInputStream( file ), "UTF-8" ) ); + try + { + for ( String line = reader.readLine(); line != null; line = reader.readLine() ) + { + int comment = line.indexOf( '#' ); + if ( comment >= 0 ) + { + line = line.substring( 0, comment ); + } + line = line.trim(); + if ( line.length() <= 0 ) + { + continue; + } + Dependency dependency = new Dependency(); + dependency.setCoords( line ); + dependencies.add( dependency ); + } + } + finally + { + reader.close(); + } + } + catch ( IOException e ) + { + throw new BuildException( "Cannot read " + file, e ); + } + return dependencies; + } + + public void install( Task task, Pom pom, Artifacts artifacts ) + { + RepositorySystemSession session = getSession( task, null ); + + InstallRequest request = new InstallRequest(); + request.setArtifacts( toArtifacts( task, session, pom, artifacts ) ); + + try + { + getSystem().install( session, request ); + } + catch ( InstallationException e ) + { + throw new BuildException( "Could not install artifacts: " + e.getMessage(), e ); + } + } + + public void deploy( Task task, Pom pom, Artifacts artifacts, RemoteRepository releaseRepository, + RemoteRepository snapshotRepository ) + { + RepositorySystemSession session = getSession( task, null ); + + DeployRequest request = new DeployRequest(); + request.setArtifacts( toArtifacts( task, session, pom, artifacts ) ); + boolean snapshot = request.getArtifacts().iterator().next().isSnapshot(); + RemoteRepository distRepo = ( snapshot && snapshotRepository != null ) ? snapshotRepository : releaseRepository; + request.setRepository( ConverterUtils.toDistRepository( distRepo, session ) ); + + try + { + getSystem().deploy( session, request ); + } + catch ( DeploymentException e ) + { + throw new BuildException( "Could not deploy artifacts: " + e.getMessage(), e ); + } + } + + private List<org.eclipse.aether.artifact.Artifact> toArtifacts( Task task, RepositorySystemSession session, + Pom pom, Artifacts artifacts ) + { + Model model = pom.getModel( task ); + File pomFile = pom.getFile(); + + List<org.eclipse.aether.artifact.Artifact> results = new ArrayList<org.eclipse.aether.artifact.Artifact>(); + + org.eclipse.aether.artifact.Artifact pomArtifact = + new DefaultArtifact( model.getGroupId(), model.getArtifactId(), "pom", model.getVersion() ).setFile( pomFile ); + results.add( pomArtifact ); + + for ( Artifact artifact : artifacts.getArtifacts() ) + { + org.eclipse.aether.artifact.Artifact buildArtifact = + new DefaultArtifact( model.getGroupId(), model.getArtifactId(), artifact.getClassifier(), + artifact.getType(), model.getVersion() ).setFile( artifact.getFile() ); + results.add( buildArtifact ); + } + + return results; + } + +}
http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/a088cdfc/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntRepositoryListener.java ---------------------------------------------------------------------- diff --git a/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntRepositoryListener.java b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntRepositoryListener.java new file mode 100644 index 0000000..f850357 --- /dev/null +++ b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntRepositoryListener.java @@ -0,0 +1,123 @@ +package org.apache.maven.resolver.internal.ant; + +/* + * 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.FileNotFoundException; + +import org.apache.tools.ant.Project; +import org.apache.tools.ant.Task; +import org.eclipse.aether.AbstractRepositoryListener; +import org.eclipse.aether.RepositoryEvent; +import org.eclipse.aether.transfer.MetadataNotFoundException; + +/** + * Logs repository events like installed and unresolved artifacts and metadata. + */ +class AntRepositoryListener + extends AbstractRepositoryListener +{ + + private Task task; + + public AntRepositoryListener( Task task ) + { + this.task = task; + } + + @Override + public void artifactInstalling( RepositoryEvent event ) + { + task.log( "Installing " + event.getArtifact().getFile() + " to " + event.getFile() ); + } + + @Override + public void metadataInstalling( RepositoryEvent event ) + { + task.log( "Installing " + event.getMetadata() + " to " + event.getFile() ); + } + + @Override + public void metadataResolved( RepositoryEvent event ) + { + Exception e = event.getException(); + if ( e != null ) + { + if ( e instanceof MetadataNotFoundException ) + { + task.log( e.getMessage(), Project.MSG_DEBUG ); + } + else + { + task.log( e.getMessage(), e, Project.MSG_WARN ); + } + } + } + + @Override + public void metadataInvalid( RepositoryEvent event ) + { + Exception exception = event.getException(); + + StringBuilder buffer = new StringBuilder( 256 ); + buffer.append( "The metadata " ); + if ( event.getMetadata().getFile() != null ) + { + buffer.append( event.getMetadata().getFile() ); + } + else + { + buffer.append( event.getMetadata() ); + } + + if ( exception instanceof FileNotFoundException ) + { + buffer.append( " is inaccessible" ); + } + else + { + buffer.append( " is invalid" ); + } + + if ( exception != null ) + { + buffer.append( ": " ); + buffer.append( exception.getMessage() ); + } + + task.log( buffer.toString(), exception, Project.MSG_WARN ); + } + + @Override + public void artifactDescriptorInvalid( RepositoryEvent event ) + { + task.log( "The POM for " + event.getArtifact() + " is invalid" + + ", transitive dependencies (if any) will not be available: " + + event.getException().getMessage(), + event.getException(), Project.MSG_WARN ); + }; + + @Override + public void artifactDescriptorMissing( RepositoryEvent event ) + { + task.log( "The POM for " + event.getArtifact() + " is missing, no dependency information available", + Project.MSG_WARN ); + }; + +} http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/a088cdfc/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntSecDispatcher.java ---------------------------------------------------------------------- diff --git a/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntSecDispatcher.java b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntSecDispatcher.java new file mode 100644 index 0000000..0852f86 --- /dev/null +++ b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntSecDispatcher.java @@ -0,0 +1,45 @@ +package org.apache.maven.resolver.internal.ant; + +/* + * 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 org.sonatype.plexus.components.cipher.DefaultPlexusCipher; +import org.sonatype.plexus.components.cipher.PlexusCipherException; +import org.sonatype.plexus.components.sec.dispatcher.DefaultSecDispatcher; + +/** + */ +class AntSecDispatcher + extends DefaultSecDispatcher +{ + + public AntSecDispatcher() + { + _configurationFile = "~/.m2/settings-security.xml"; + try + { + _cipher = new DefaultPlexusCipher(); + } + catch ( PlexusCipherException e ) + { + e.printStackTrace(); + } + } + +} http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/a088cdfc/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntServiceLocatorErrorHandler.java ---------------------------------------------------------------------- diff --git a/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntServiceLocatorErrorHandler.java b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntServiceLocatorErrorHandler.java new file mode 100644 index 0000000..1621285 --- /dev/null +++ b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntServiceLocatorErrorHandler.java @@ -0,0 +1,50 @@ +package org.apache.maven.resolver.internal.ant; + +/* + * 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 org.apache.tools.ant.Project; +import org.eclipse.aether.RepositorySystem; +import org.eclipse.aether.impl.DefaultServiceLocator; + +/** + */ +class AntServiceLocatorErrorHandler + extends DefaultServiceLocator.ErrorHandler +{ + + private Project project; + + public AntServiceLocatorErrorHandler( Project project ) + { + this.project = project; + } + + public void serviceCreationFailed( Class<?> type, Class<?> impl, Throwable exception ) + { + String msg = "Could not initialize repository system"; + if ( !RepositorySystem.class.equals( type ) ) + { + msg += ", service " + type.getName() + " (" + impl.getName() + ") failed to initialize"; + } + msg += ": " + exception.getMessage(); + project.log( msg, exception, Project.MSG_ERR ); + } + +} http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/a088cdfc/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntSettingsDecryptorFactory.java ---------------------------------------------------------------------- diff --git a/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntSettingsDecryptorFactory.java b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntSettingsDecryptorFactory.java new file mode 100644 index 0000000..39ef960 --- /dev/null +++ b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntSettingsDecryptorFactory.java @@ -0,0 +1,51 @@ +package org.apache.maven.resolver.internal.ant; + +/* + * 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.lang.reflect.Field; + +import org.apache.maven.settings.crypto.DefaultSettingsDecrypter; + +/** + */ +class AntSettingsDecryptorFactory +{ + + public DefaultSettingsDecrypter newInstance() + { + AntSecDispatcher secDispatcher = new AntSecDispatcher(); + + DefaultSettingsDecrypter decrypter = new DefaultSettingsDecrypter(); + + try + { + Field field = decrypter.getClass().getDeclaredField( "securityDispatcher" ); + field.setAccessible( true ); + field.set( decrypter, secDispatcher ); + } + catch ( Exception e ) + { + throw new IllegalStateException( e ); + } + + return decrypter; + } + +} http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/a088cdfc/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntTransferListener.java ---------------------------------------------------------------------- diff --git a/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntTransferListener.java b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntTransferListener.java new file mode 100644 index 0000000..6844d22 --- /dev/null +++ b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/AntTransferListener.java @@ -0,0 +1,91 @@ +package org.apache.maven.resolver.internal.ant; + +/* + * 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.text.DecimalFormat; +import java.text.DecimalFormatSymbols; +import java.util.Locale; + +import org.apache.tools.ant.Project; +import org.apache.tools.ant.Task; +import org.eclipse.aether.transfer.AbstractTransferListener; +import org.eclipse.aether.transfer.TransferCancelledException; +import org.eclipse.aether.transfer.TransferEvent; +import org.eclipse.aether.transfer.TransferResource; + +/** + * Logs up- and downloads. + */ +class AntTransferListener + extends AbstractTransferListener +{ + + private Task task; + + public AntTransferListener( Task task ) + { + this.task = task; + } + + @Override + public void transferInitiated( TransferEvent event ) + throws TransferCancelledException + { + String msg = event.getRequestType() == TransferEvent.RequestType.PUT ? "Uploading" : "Downloading"; + msg += " " + event.getResource().getRepositoryUrl() + event.getResource().getResourceName(); + task.log( msg ); + } + + @Override + public void transferCorrupted( TransferEvent event ) + throws TransferCancelledException + { + TransferResource resource = event.getResource(); + + task.log( event.getException().getMessage() + " for " + resource.getRepositoryUrl() + + resource.getResourceName(), Project.MSG_WARN ); + } + + @Override + public void transferSucceeded( TransferEvent event ) + { + String msg = event.getRequestType() == TransferEvent.RequestType.PUT ? "Uploaded" : "Downloaded"; + msg += " " + event.getResource().getRepositoryUrl() + event.getResource().getResourceName(); + + long contentLength = event.getTransferredBytes(); + if ( contentLength >= 0 ) + { + String len = contentLength >= 1024 ? ( ( contentLength + 1023 ) / 1024 ) + " KB" : contentLength + " B"; + + String throughput = ""; + long duration = System.currentTimeMillis() - event.getResource().getTransferStartTime(); + if ( duration > 0 ) + { + DecimalFormat format = new DecimalFormat( "0.0", new DecimalFormatSymbols( Locale.ENGLISH ) ); + double kbPerSec = ( contentLength / 1024.0 ) / ( duration / 1000.0 ); + throughput = " at " + format.format( kbPerSec ) + " KB/sec"; + } + + msg += " (" + len + throughput + ")"; + } + task.log( msg ); + } + +} http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/a088cdfc/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/ConverterUtils.java ---------------------------------------------------------------------- diff --git a/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/ConverterUtils.java b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/ConverterUtils.java new file mode 100644 index 0000000..6452ec1 --- /dev/null +++ b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/ConverterUtils.java @@ -0,0 +1,227 @@ +package org.apache.maven.resolver.internal.ant; + +/* + * 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.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Properties; + +import org.apache.maven.resolver.internal.ant.types.Authentication; +import org.apache.maven.resolver.internal.ant.types.Dependency; +import org.apache.maven.resolver.internal.ant.types.Exclusion; +import org.apache.maven.resolver.internal.ant.types.Proxy; +import org.apache.maven.resolver.internal.ant.types.RemoteRepositories; +import org.apache.maven.resolver.internal.ant.types.RemoteRepository; +import org.apache.tools.ant.Project; +import org.eclipse.aether.RepositorySystemSession; +import org.eclipse.aether.artifact.Artifact; +import org.eclipse.aether.artifact.ArtifactProperties; +import org.eclipse.aether.artifact.ArtifactType; +import org.eclipse.aether.artifact.ArtifactTypeRegistry; +import org.eclipse.aether.artifact.DefaultArtifact; +import org.eclipse.aether.artifact.DefaultArtifactType; +import org.eclipse.aether.impl.RemoteRepositoryManager; +import org.eclipse.aether.repository.RepositoryPolicy; +import org.eclipse.aether.util.repository.AuthenticationBuilder; + +/** + * Utility methods to convert between Aether and Ant objects. + */ +class ConverterUtils +{ + + private static org.eclipse.aether.artifact.Artifact toArtifact( Dependency dependency, ArtifactTypeRegistry types ) + { + ArtifactType type = types.get( dependency.getType() ); + if ( type == null ) + { + type = new DefaultArtifactType( dependency.getType() ); + } + + Map<String, String> props = null; + if ( "system".equals( dependency.getScope() ) && dependency.getSystemPath() != null ) + { + props = Collections.singletonMap( ArtifactProperties.LOCAL_PATH, dependency.getSystemPath().getPath() ); + } + + Artifact artifact = + new DefaultArtifact( dependency.getGroupId(), dependency.getArtifactId(), dependency.getClassifier(), null, + dependency.getVersion(), props, type ); + + return artifact; + } + + public static org.eclipse.aether.repository.Authentication toAuthentication( Authentication auth ) + { + if ( auth == null ) + { + return null; + } + AuthenticationBuilder authBuilder = new AuthenticationBuilder(); + authBuilder.addUsername( auth.getUsername() ).addPassword( auth.getPassword() ); + authBuilder.addPrivateKey( auth.getPrivateKeyFile(), auth.getPassphrase() ); + return authBuilder.build(); + } + + public static org.eclipse.aether.graph.Dependency toDependency( Dependency dependency, List<Exclusion> exclusions, + RepositorySystemSession session ) + { + return new org.eclipse.aether.graph.Dependency( toArtifact( dependency, session.getArtifactTypeRegistry() ), + dependency.getScope(), false, + toExclusions( dependency.getExclusions(), exclusions ) ); + } + + /** + * Converts the given ant repository type to an Aether repository instance with authentication and proxy filled in + * via the sessions' selectors. + */ + public static org.eclipse.aether.repository.RemoteRepository toDistRepository( RemoteRepository repo, + RepositorySystemSession session ) + { + org.eclipse.aether.repository.RemoteRepository result = toRepository( repo ); + org.eclipse.aether.repository.RemoteRepository.Builder builder = + new org.eclipse.aether.repository.RemoteRepository.Builder( result ); + builder.setAuthentication( session.getAuthenticationSelector().getAuthentication( result ) ); + builder.setProxy( session.getProxySelector().getProxy( result ) ); + return builder.build(); + } + + private static org.eclipse.aether.graph.Exclusion toExclusion( Exclusion exclusion ) + { + return new org.eclipse.aether.graph.Exclusion( exclusion.getGroupId(), exclusion.getArtifactId(), + exclusion.getClassifier(), exclusion.getExtension() ); + } + + private static Collection<org.eclipse.aether.graph.Exclusion> toExclusions( Collection<Exclusion> exclusions1, + Collection<Exclusion> exclusions2 ) + { + Collection<org.eclipse.aether.graph.Exclusion> results = + new LinkedHashSet<org.eclipse.aether.graph.Exclusion>(); + if ( exclusions1 != null ) + { + for ( Exclusion exclusion : exclusions1 ) + { + results.add( toExclusion( exclusion ) ); + } + } + if ( exclusions2 != null ) + { + for ( Exclusion exclusion : exclusions2 ) + { + results.add( toExclusion( exclusion ) ); + } + } + return results; + } + + private static RepositoryPolicy toPolicy( RemoteRepository.Policy policy, boolean enabled, String updates, + String checksums ) + { + if ( policy != null ) + { + enabled = policy.isEnabled(); + if ( policy.getChecksums() != null ) + { + checksums = policy.getChecksums(); + } + if ( policy.getUpdates() != null ) + { + updates = policy.getUpdates(); + } + } + return new RepositoryPolicy( enabled, updates, checksums ); + } + + /** + * Adds every <String, String>-entry in the map as a property to the given Properties. + */ + public static Properties addProperties( Properties props, Map<?, ?> map ) + { + if ( props == null ) + { + props = new Properties(); + } + for ( Map.Entry<?, ?> entry : map.entrySet() ) + { + if ( entry.getKey() instanceof String && entry.getValue() instanceof String ) + { + props.put( entry.getKey(), entry.getValue() ); + } + } + return props; + } + + public static org.eclipse.aether.repository.Proxy toProxy( Proxy proxy ) + { + if ( proxy == null ) + { + return null; + } + return new org.eclipse.aether.repository.Proxy( proxy.getType(), proxy.getHost(), proxy.getPort(), + toAuthentication( proxy.getAuthentication() ) ); + } + + private static org.eclipse.aether.repository.RemoteRepository toRepository( RemoteRepository repo ) + { + org.eclipse.aether.repository.RemoteRepository.Builder builder = + new org.eclipse.aether.repository.RemoteRepository.Builder( repo.getId(), repo.getType(), repo.getUrl() ); + builder.setSnapshotPolicy( toPolicy( repo.getSnapshotPolicy(), repo.isSnapshots(), repo.getUpdates(), + repo.getChecksums() ) ); + builder.setReleasePolicy( toPolicy( repo.getReleasePolicy(), repo.isReleases(), repo.getUpdates(), + repo.getChecksums() ) ); + builder.setAuthentication( toAuthentication( repo.getAuthentication() ) ); + return builder.build(); + } + + public static List<org.eclipse.aether.repository.RemoteRepository> toRepositories( Project project, + RepositorySystemSession session, + RemoteRepositories repos, RemoteRepositoryManager remoteRepositoryManager ) + { + List<RemoteRepository> repositories; + + if ( repos != null ) + { + repositories = repos.getRepositories(); + } + else + { + repositories = new ArrayList<RemoteRepository>(); + } + + List<org.eclipse.aether.repository.RemoteRepository> results = + new ArrayList<org.eclipse.aether.repository.RemoteRepository>(); + for ( RemoteRepository repo : repositories ) + { + results.add( toRepository( repo ) ); + } + + results = + remoteRepositoryManager.aggregateRepositories( session, + Collections.<org.eclipse.aether.repository.RemoteRepository>emptyList(), + results, true ); + + return results; + } + +} http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/a088cdfc/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/Names.java ---------------------------------------------------------------------- diff --git a/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/Names.java b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/Names.java new file mode 100644 index 0000000..122bafa --- /dev/null +++ b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/Names.java @@ -0,0 +1,44 @@ +package org.apache.maven.resolver.internal.ant; + +/* + * 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. + */ + +/** + */ +public final class Names +{ + + private Names() + { + // hide constructor + } + + public static final String ID = "resolver"; + + public static final String ID_DEFAULT_REPOS = ID + ".repositories"; + + public static final String ID_DEFAULT_POM = ID + ".pom"; + + public static final String ID_CENTRAL = "central"; + + public static final String PROPERTY_OFFLINE = ID + ".offline"; + + public static final String SETTINGS_XML = "settings.xml"; + +} http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/a088cdfc/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/ProjectWorkspaceReader.java ---------------------------------------------------------------------- diff --git a/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/ProjectWorkspaceReader.java b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/ProjectWorkspaceReader.java new file mode 100644 index 0000000..8ae2857 --- /dev/null +++ b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/ProjectWorkspaceReader.java @@ -0,0 +1,144 @@ +package org.apache.maven.resolver.internal.ant; + +/* + * 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.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +import org.apache.maven.model.Model; +import org.apache.maven.resolver.internal.ant.types.Pom; +import org.eclipse.aether.artifact.Artifact; +import org.eclipse.aether.artifact.DefaultArtifact; +import org.eclipse.aether.repository.WorkspaceReader; +import org.eclipse.aether.repository.WorkspaceRepository; +import org.eclipse.aether.util.artifact.ArtifactIdUtils; + +/** + * Workspace reader caching available POMs and artifacts for ant builds. + * <p/> + * <pom> elements are cached if they are defined by the 'file'-attribute, as they reference a backing pom.xml file that + * can be used for resolution with Aether. <artifact> elements are cached if they directly define a 'pom'-attribute + * or child. The POM may be file-based or in-memory. + */ +public class ProjectWorkspaceReader + implements WorkspaceReader +{ + + private static volatile ProjectWorkspaceReader instance; + + private static final Object LOCK = new Object(); + + private Map<String, Artifact> artifacts = new ConcurrentHashMap<String, Artifact>(); + + public void addPom( Pom pom ) + { + if ( pom.getFile() != null ) + { + Model model = pom.getModel( pom ); + Artifact aetherArtifact = + new DefaultArtifact( model.getGroupId(), model.getArtifactId(), null, "pom", model.getVersion() ); + aetherArtifact = aetherArtifact.setFile( pom.getFile() ); + String coords = coords( aetherArtifact ); + artifacts.put( coords, aetherArtifact ); + } + } + + public void addArtifact( org.apache.maven.resolver.internal.ant.types.Artifact artifact ) + { + if ( artifact.getPom() != null ) + { + Pom pom = artifact.getPom(); + Artifact aetherArtifact; + if ( pom.getFile() != null ) + { + Model model = pom.getModel( pom ); + aetherArtifact = + new DefaultArtifact( model.getGroupId(), model.getArtifactId(), artifact.getClassifier(), + artifact.getType(), model.getVersion() ); + } + else + { + aetherArtifact = + new DefaultArtifact( pom.getGroupId(), pom.getArtifactId(), artifact.getClassifier(), + artifact.getType(), pom.getVersion() ); + } + aetherArtifact = aetherArtifact.setFile( artifact.getFile() ); + + String coords = coords( aetherArtifact ); + artifacts.put( coords, aetherArtifact ); + } + } + + private String coords( Artifact artifact ) + { + return ArtifactIdUtils.toId( artifact ); + } + + public WorkspaceRepository getRepository() + { + return new WorkspaceRepository( "ant" ); + } + + public File findArtifact( Artifact artifact ) + { + artifact = artifacts.get( coords( artifact ) ); + return ( artifact != null ) ? artifact.getFile() : null; + } + + public List<String> findVersions( Artifact artifact ) + { + List<String> versions = new ArrayList<String>(); + for ( Artifact art : artifacts.values() ) + { + if ( ArtifactIdUtils.equalsVersionlessId( artifact, art ) ) + { + versions.add( art.getVersion() ); + } + } + return versions; + } + + ProjectWorkspaceReader() + { + } + + public static ProjectWorkspaceReader getInstance() + { + if ( instance == null ) + { + synchronized ( LOCK ) + { + if ( instance == null ) + { + instance = new ProjectWorkspaceReader(); + } + } + } + return instance; + } + + static void dropInstance() + { + instance = null; + } +} http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/a088cdfc/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/SettingsUtils.java ---------------------------------------------------------------------- diff --git a/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/SettingsUtils.java b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/SettingsUtils.java new file mode 100644 index 0000000..51cb0d1 --- /dev/null +++ b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/SettingsUtils.java @@ -0,0 +1,182 @@ +package org.apache.maven.resolver.internal.ant; + +/* + * 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.util.ArrayList; +import java.util.List; + +import org.apache.maven.settings.Activation; +import org.apache.maven.settings.ActivationFile; +import org.apache.maven.settings.ActivationOS; +import org.apache.maven.settings.ActivationProperty; +import org.apache.maven.settings.Profile; +import org.apache.maven.settings.Repository; +import org.apache.maven.settings.RepositoryPolicy; + +/** + * Utility methods to read settings from Mavens settings.xml. + */ +class SettingsUtils +{ + + public static List<org.apache.maven.model.Profile> convert( List<Profile> profiles ) + { + if ( profiles == null ) + { + return null; + } + + List<org.apache.maven.model.Profile> results = new ArrayList<org.apache.maven.model.Profile>(); + + for ( Profile profile : profiles ) + { + results.add( convert( profile ) ); + } + + return results; + } + + static org.apache.maven.model.Profile convert( Profile profile ) + { + if ( profile == null ) + { + return null; + } + + org.apache.maven.model.Profile result = new org.apache.maven.model.Profile(); + + result.setId( profile.getId() ); + result.setProperties( profile.getProperties() ); + result.setSource( "settings.xml" ); + result.setActivation( convert( profile.getActivation() ) ); + + for ( Repository repo : profile.getRepositories() ) + { + result.addRepository( convert( repo ) ); + } + + for ( Repository repo : profile.getPluginRepositories() ) + { + result.addPluginRepository( convert( repo ) ); + } + + return result; + } + + static org.apache.maven.model.Activation convert( Activation activation ) + { + if ( activation == null ) + { + return null; + } + + org.apache.maven.model.Activation result = new org.apache.maven.model.Activation(); + + result.setActiveByDefault( activation.isActiveByDefault() ); + result.setJdk( activation.getJdk() ); + result.setFile( convert( activation.getFile() ) ); + result.setProperty( convert( activation.getProperty() ) ); + result.setOs( convert( activation.getOs() ) ); + + return result; + } + + static org.apache.maven.model.ActivationOS convert( ActivationOS activation ) + { + if ( activation == null ) + { + return null; + } + + org.apache.maven.model.ActivationOS result = new org.apache.maven.model.ActivationOS(); + + result.setArch( activation.getArch() ); + result.setFamily( activation.getFamily() ); + result.setName( activation.getName() ); + result.setVersion( activation.getVersion() ); + + return result; + } + + static org.apache.maven.model.ActivationProperty convert( ActivationProperty activation ) + { + if ( activation == null ) + { + return null; + } + + org.apache.maven.model.ActivationProperty result = new org.apache.maven.model.ActivationProperty(); + + result.setName( activation.getName() ); + result.setValue( activation.getValue() ); + + return result; + } + + static org.apache.maven.model.ActivationFile convert( ActivationFile activation ) + { + if ( activation == null ) + { + return null; + } + + org.apache.maven.model.ActivationFile result = new org.apache.maven.model.ActivationFile(); + + result.setExists( activation.getExists() ); + result.setMissing( activation.getMissing() ); + + return result; + } + + static org.apache.maven.model.Repository convert( Repository repo ) + { + if ( repo == null ) + { + return null; + } + + org.apache.maven.model.Repository result = new org.apache.maven.model.Repository(); + + result.setId( repo.getId() ); + result.setUrl( repo.getUrl() ); + result.setLayout( repo.getLayout() ); + result.setReleases( convert( repo.getReleases() ) ); + result.setSnapshots( convert( repo.getSnapshots() ) ); + + return result; + } + + static org.apache.maven.model.RepositoryPolicy convert( RepositoryPolicy policy ) + { + if ( policy == null ) + { + return null; + } + + org.apache.maven.model.RepositoryPolicy result = new org.apache.maven.model.RepositoryPolicy(); + + result.setEnabled( policy.isEnabled() ); + result.setChecksumPolicy( policy.getChecksumPolicy() ); + result.setUpdatePolicy( policy.getUpdatePolicy() ); + + return result; + } + +} http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/a088cdfc/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/AbstractDistTask.java ---------------------------------------------------------------------- diff --git a/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/AbstractDistTask.java b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/AbstractDistTask.java new file mode 100644 index 0000000..70bebbc --- /dev/null +++ b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/AbstractDistTask.java @@ -0,0 +1,180 @@ +package org.apache.maven.resolver.internal.ant.tasks; + +/* + * 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.HashMap; +import java.util.Map; + +import org.apache.maven.model.Model; +import org.apache.maven.resolver.internal.ant.AntRepoSys; +import org.apache.maven.resolver.internal.ant.types.Artifact; +import org.apache.maven.resolver.internal.ant.types.Artifacts; +import org.apache.maven.resolver.internal.ant.types.Pom; +import org.apache.tools.ant.BuildException; +import org.apache.tools.ant.Project; +import org.apache.tools.ant.Task; +import org.apache.tools.ant.types.Reference; + +/** + */ +public abstract class AbstractDistTask + extends Task +{ + + private Pom pom; + + private Artifacts artifacts; + + protected void validate() + { + getArtifacts().validate( this ); + + Map<String, File> duplicates = new HashMap<String, File>(); + for ( Artifact artifact : getArtifacts().getArtifacts() ) + { + String key = artifact.getType() + ':' + artifact.getClassifier(); + if ( "pom:".equals( key ) ) + { + throw new BuildException( "You must not specify an <artifact> with type=pom" + + ", please use the <pom> element instead." ); + } + else if ( duplicates.containsKey( key ) ) + { + throw new BuildException( "You must not specify two or more artifacts with the same type (" + + artifact.getType() + ") and classifier (" + artifact.getClassifier() + ")" ); + } + else + { + duplicates.put( key, artifact.getFile() ); + } + + validateArtifactGav( artifact ); + } + + Pom defaultPom = AntRepoSys.getInstance( getProject() ).getDefaultPom(); + if ( pom == null && defaultPom != null ) + { + log( "Using default POM (" + defaultPom.getCoords() + ")", Project.MSG_INFO ); + pom = defaultPom; + } + + if ( pom == null ) + { + throw new BuildException( "You must specify the <pom file=\"...\"> element" + + " to denote the descriptor for the artifacts" ); + } + if ( pom.getFile() == null ) + { + throw new BuildException( "You must specify a <pom> element that has the 'file' attribute set" ); + } + } + + private void validateArtifactGav( Artifact artifact ) + { + Pom artifactPom = artifact.getPom(); + if ( artifactPom != null ) + { + String gid; + String aid; + String version; + if ( artifactPom.getFile() != null ) + { + Model model = artifactPom.getModel( this ); + gid = model.getGroupId(); + aid = model.getArtifactId(); + version = model.getVersion(); + } + else + { + gid = artifactPom.getGroupId(); + aid = artifactPom.getArtifactId(); + version = artifactPom.getVersion(); + } + + Model model = getPom().getModel( this ); + + if ( ! ( model.getGroupId().equals( gid ) && model.getArtifactId().equals( aid ) && model.getVersion().equals( version ) ) ) + { + throw new BuildException( "Artifact references different pom than it would be installed with: " + + artifact.toString() ); + } + } + } + + protected Artifacts getArtifacts() + { + if ( artifacts == null ) + { + artifacts = new Artifacts(); + artifacts.setProject( getProject() ); + } + return artifacts; + } + + public void addArtifact( Artifact artifact ) + { + getArtifacts().addArtifact( artifact ); + } + + public void addArtifacts( Artifacts artifacts ) + { + getArtifacts().addArtifacts( artifacts ); + } + + public void setArtifactsRef( Reference ref ) + { + Artifacts artifacts = new Artifacts(); + artifacts.setProject( getProject() ); + artifacts.setRefid( ref ); + getArtifacts().addArtifacts( artifacts ); + } + + protected Pom getPom() + { + if ( pom == null ) + { + return AntRepoSys.getInstance( getProject() ).getDefaultPom(); + } + + return pom; + } + + public void addPom( Pom pom ) + { + if ( this.pom != null ) + { + throw new BuildException( "You must not specify multiple <pom> elements" ); + } + this.pom = pom; + } + + public void setPomRef( Reference ref ) + { + if ( this.pom != null ) + { + throw new BuildException( "You must not specify multiple <pom> elements" ); + } + pom = new Pom(); + pom.setProject( getProject() ); + pom.setRefid( ref ); + } + +} http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/a088cdfc/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/AbstractResolvingTask.java ---------------------------------------------------------------------- diff --git a/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/AbstractResolvingTask.java b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/AbstractResolvingTask.java new file mode 100644 index 0000000..c19e086 --- /dev/null +++ b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/AbstractResolvingTask.java @@ -0,0 +1,107 @@ +package org.apache.maven.resolver.internal.ant.tasks; + +/* + * 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 org.apache.maven.resolver.internal.ant.AntRepoSys; +import org.apache.maven.resolver.internal.ant.types.Dependencies; +import org.apache.maven.resolver.internal.ant.types.LocalRepository; +import org.apache.maven.resolver.internal.ant.types.RemoteRepositories; +import org.apache.maven.resolver.internal.ant.types.RemoteRepository; +import org.apache.tools.ant.BuildException; +import org.apache.tools.ant.Task; +import org.apache.tools.ant.types.Reference; +import org.eclipse.aether.collection.CollectResult; + +/** + */ +public abstract class AbstractResolvingTask + extends Task +{ + + protected Dependencies dependencies; + + protected RemoteRepositories remoteRepositories; + + protected LocalRepository localRepository; + + public void addDependencies( Dependencies dependencies ) + { + if ( this.dependencies != null ) + { + throw new BuildException( "You must not specify multiple <dependencies> elements" ); + } + this.dependencies = dependencies; + } + + public void setDependenciesRef( Reference ref ) + { + if ( dependencies == null ) + { + dependencies = new Dependencies(); + dependencies.setProject( getProject() ); + } + dependencies.setRefid( ref ); + } + + public LocalRepository createLocalRepo() + { + if ( localRepository != null ) + { + throw new BuildException( "You must not specify multiple <localRepo> elements" ); + } + localRepository = new LocalRepository( this ); + return localRepository; + } + + private RemoteRepositories getRemoteRepos() + { + if ( remoteRepositories == null ) + { + remoteRepositories = new RemoteRepositories(); + remoteRepositories.setProject( getProject() ); + } + return remoteRepositories; + } + + public void addRemoteRepo( RemoteRepository repository ) + { + getRemoteRepos().addRemoterepo( repository ); + } + + public void addRemoteRepos( RemoteRepositories repositories ) + { + getRemoteRepos().addRemoterepos( repositories ); + } + + public void setRemoteReposRef( Reference ref ) + { + RemoteRepositories repos = new RemoteRepositories(); + repos.setProject( getProject() ); + repos.setRefid( ref ); + getRemoteRepos().addRemoterepos( repos ); + } + + protected CollectResult collectDependencies() + { + return AntRepoSys.getInstance( getProject() ).collectDependencies( this, dependencies, localRepository, + remoteRepositories ); + } + +} http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/a088cdfc/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/DependencyGraphLogger.java ---------------------------------------------------------------------- diff --git a/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/DependencyGraphLogger.java b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/DependencyGraphLogger.java new file mode 100644 index 0000000..c1fff1d --- /dev/null +++ b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/DependencyGraphLogger.java @@ -0,0 +1,85 @@ +package org.apache.maven.resolver.internal.ant.tasks; + +/* + * 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 org.apache.tools.ant.Project; +import org.apache.tools.ant.Task; +import org.eclipse.aether.artifact.Artifact; +import org.eclipse.aether.graph.Dependency; +import org.eclipse.aether.graph.DependencyNode; +import org.eclipse.aether.graph.DependencyVisitor; +import org.eclipse.aether.util.graph.manager.DependencyManagerUtils; + +/** + */ +class DependencyGraphLogger + implements DependencyVisitor +{ + + private Task task; + + private String indent = ""; + + public DependencyGraphLogger( Task task ) + { + this.task = task; + } + + public boolean visitEnter( DependencyNode node ) + { + StringBuilder buffer = new StringBuilder( 128 ); + buffer.append( indent ); + Dependency dep = node.getDependency(); + if ( dep != null ) + { + Artifact art = dep.getArtifact(); + + buffer.append( art ); + buffer.append( ':' ).append( dep.getScope() ); + + String premanagedScope = DependencyManagerUtils.getPremanagedScope( node ); + if ( premanagedScope != null && !premanagedScope.equals( dep.getScope() ) ) + { + buffer.append( " (scope managed from " ).append( premanagedScope ).append( ")" ); + } + + String premanagedVersion = DependencyManagerUtils.getPremanagedVersion( node ); + if ( premanagedVersion != null && !premanagedVersion.equals( art.getVersion() ) ) + { + buffer.append( " (version managed from " ).append( premanagedVersion ).append( ")" ); + } + } + else + { + buffer.append( "Resolved Dependency Graph:" ); + } + + task.log( buffer.toString(), Project.MSG_VERBOSE ); + indent += " "; + return true; + } + + public boolean visitLeave( DependencyNode node ) + { + indent = indent.substring( 0, indent.length() - 3 ); + return true; + } + +} http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/a088cdfc/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/Deploy.java ---------------------------------------------------------------------- diff --git a/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/Deploy.java b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/Deploy.java new file mode 100644 index 0000000..742dbc0 --- /dev/null +++ b/maven-resolver-ant-tasks/src/main/java/org/apache/maven/resolver/internal/ant/tasks/Deploy.java @@ -0,0 +1,104 @@ +package org.apache.maven.resolver.internal.ant.tasks; + +/* + * 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 org.apache.maven.resolver.internal.ant.AntRepoSys; +import org.apache.maven.resolver.internal.ant.types.RemoteRepository; +import org.apache.tools.ant.BuildException; +import org.apache.tools.ant.types.Reference; + +/** + */ +public class Deploy + extends AbstractDistTask +{ + + private RemoteRepository repository; + + private RemoteRepository snapshotRepository; + + @Override + protected void validate() + { + super.validate(); + + if ( repository == null ) + { + throw new BuildException( "You must specify the <remoteRepo id=\"...\" url=\"...\"> element" + + " to denote the target repository for the deployment" ); + } + else + { + repository.validate( this ); + } + if ( snapshotRepository != null ) + { + snapshotRepository.validate( this ); + } + } + + public void addRemoteRepo( RemoteRepository repository ) + { + if ( this.repository != null ) + { + throw new BuildException( "You must not specify multiple <remoteRepo> elements" ); + } + this.repository = repository; + } + + public void setRemoteRepoRef( Reference ref ) + { + if ( repository == null ) + { + repository = new RemoteRepository(); + repository.setProject( getProject() ); + } + repository.setRefid( ref ); + } + + public void addSnapshotRepo( RemoteRepository snapshotRepository ) + { + if ( this.snapshotRepository != null ) + { + throw new BuildException( "You must not specify multiple <snapshotRepo> elements" ); + } + this.snapshotRepository = snapshotRepository; + } + + public void setSnapshotRepoRef( Reference ref ) + { + if ( snapshotRepository == null ) + { + snapshotRepository = new RemoteRepository(); + snapshotRepository.setProject( getProject() ); + } + snapshotRepository.setRefid( ref ); + } + + @Override + public void execute() + throws BuildException + { + validate(); + + AntRepoSys.getInstance( getProject() ).deploy( this, getPom(), getArtifacts(), repository, snapshotRepository ); + } + +}
