| package org.apache.axis2.maven2.aar; |
| |
| /* |
| * Copyright 2006 The Apache Software Foundation. |
| * |
| * Licensed 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.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.apache.maven.artifact.Artifact; |
| import org.apache.maven.artifact.resolver.filter.ScopeArtifactFilter; |
| import org.apache.maven.plugin.AbstractMojo; |
| import org.apache.maven.plugin.MojoExecutionException; |
| import org.apache.maven.project.MavenProject; |
| import org.codehaus.plexus.util.DirectoryScanner; |
| import org.codehaus.plexus.util.FileUtils; |
| |
| |
| |
| /** |
| * Abstract base class of all the mojos in the axis2-aar-maven-plugin. |
| */ |
| public abstract class AbstractAarMojo |
| extends AbstractMojo |
| { |
| |
| /** |
| * The projects base directory. |
| * |
| * @parameter expression="${project.basedir}" |
| * @required |
| * @readonly |
| */ |
| protected File baseDir; |
| |
| /** |
| * The maven project. |
| * |
| * @parameter expression="${project}" |
| * @required |
| * @readonly |
| */ |
| protected MavenProject project; |
| |
| /** |
| * The directory containing generated classes. |
| * |
| * @parameter expression="${project.build.outputDirectory}" |
| * @required |
| */ |
| private File classesDirectory; |
| |
| /** |
| * The directory where the aar is built. |
| * |
| * @parameter expression="${project.build.directory}/aar" |
| * @required |
| */ |
| protected File aarDirectory; |
| |
| /** |
| * The location of the services.xml file. If it is present in the META-INF |
| * directory in src/main/resources with that name then it will automatically be |
| * included. Otherwise this parameter must be set. |
| * |
| * @parameter |
| */ |
| private File servicesXmlFile; |
| |
| /** |
| * The location of the WSDL file, if any. By default, no WSDL file is added |
| * and it is assumed, that Axis 2 will automatically generate a WSDL file. |
| * |
| * @parameter |
| */ |
| private File wsdlFile; |
| |
| /** |
| * Name, to which the wsdl file shall be mapped. By default, the name will |
| * be computed from the files path by removing the directory. |
| * |
| * @parameter default-value="service.wsdl" |
| */ |
| private String wsdlFileName; |
| |
| /** |
| * Additional file sets, which are being added to the archive. |
| * |
| * @parameter |
| */ |
| private FileSet[] fileSets; |
| |
| /** |
| * Builds the exploded AAR file. |
| * @throws MojoExecutionException |
| */ |
| protected void buildExplodedAar( ) |
| throws MojoExecutionException |
| { |
| getLog().debug( "Exploding aar..." ); |
| |
| aarDirectory.mkdirs(); |
| getLog().debug( "Assembling aar " + project.getArtifactId() + " in " + aarDirectory ); |
| |
| try |
| { |
| final File metaInfDir = new File( aarDirectory, "META-INF" ); |
| final File libDir = new File(aarDirectory, "lib");
|
| final File servicesFileTarget = new File( metaInfDir, "services.xml" ); |
| boolean existsBeforeCopyingClasses = servicesFileTarget.exists(); |
| |
| String wsdlName = wsdlFileName; |
| if ( wsdlName == null && wsdlFile != null ) |
| { |
| wsdlName = wsdlFile.getName(); |
| } |
| File wsdlFileTarget = null; |
| if ( wsdlFile != null ) |
| { |
| wsdlFileTarget = new File( metaInfDir, wsdlFileName ); |
| } |
| boolean wsdlExistsBeforeCopyingClasses = wsdlFileTarget == null ? false : wsdlFileTarget.exists(); |
| |
| if ( classesDirectory.exists() && ( !classesDirectory.equals( aarDirectory ) ) ) |
| { |
| FileUtils.copyDirectoryStructure( classesDirectory, aarDirectory ); |
| } |
| |
| if ( fileSets != null ) |
| { |
| for ( int i = 0; i < fileSets.length; i++ ) |
| { |
| FileSet fileSet = fileSets[i]; |
| copyFileSet( fileSet, aarDirectory ); |
| } |
| } |
| |
| copyMetaInfFile( servicesXmlFile, servicesFileTarget, existsBeforeCopyingClasses, "services.xml file" ); |
| copyMetaInfFile( wsdlFile, wsdlFileTarget, wsdlExistsBeforeCopyingClasses, "WSDL file" ); |
|
|
| Set artifacts = project.getArtifacts();
|
|
|
| List duplicates = findDuplicates( artifacts );
|
|
|
| for ( Iterator iter = artifacts.iterator(); iter.hasNext(); )
|
| {
|
| Artifact artifact = (Artifact) iter.next();
|
| String targetFileName = getDefaultFinalName( artifact );
|
|
|
| getLog().debug( "Processing: " + targetFileName );
|
|
|
| if ( duplicates.contains( targetFileName ) )
|
| {
|
| getLog().debug( "Duplicate found: " + targetFileName );
|
| targetFileName = artifact.getGroupId() + "-" + targetFileName;
|
| getLog().debug( "Renamed to: " + targetFileName );
|
| } |
|
|
| // TODO: utilise appropriate methods from project builder
|
| ScopeArtifactFilter filter = new ScopeArtifactFilter( Artifact.SCOPE_RUNTIME );
|
| if ( !artifact.isOptional() && filter.include( artifact ) )
|
| {
|
| String type = artifact.getType();
|
| if ( "jar".equals( type ) )
|
| {
|
| copyFileIfModified( artifact.getFile(), new File( libDir, targetFileName ) );
|
| }
|
| }
|
| }
|
| }
|
| catch ( IOException e ) |
| { |
| throw new MojoExecutionException( "Could not explode aar...", e ); |
| } |
| } |
| |
| /**
|
| * Searches a set of artifacts for duplicate filenames and returns a list of duplicates.
|
| *
|
| * @param artifacts set of artifacts
|
| * @return List of duplicated artifacts
|
| */
|
| private List findDuplicates( Set artifacts )
|
| {
|
| List duplicates = new ArrayList();
|
| List identifiers = new ArrayList();
|
| for ( Iterator iter = artifacts.iterator(); iter.hasNext(); )
|
| {
|
| Artifact artifact = (Artifact) iter.next();
|
| String candidate = getDefaultFinalName( artifact );
|
| if ( identifiers.contains( candidate ) )
|
| {
|
| duplicates.add( candidate );
|
| }
|
| else
|
| {
|
| identifiers.add( candidate );
|
| }
|
| }
|
| return duplicates;
|
| }
|
| |
| /**
|
| * Converts the filename of an artifact to artifactId-version.type format.
|
| *
|
| * @param artifact
|
| * @return converted filename of the artifact
|
| */
|
| private String getDefaultFinalName( Artifact artifact )
|
| {
|
| return artifact.getArtifactId() + "-" + artifact.getVersion() + "." +
|
| artifact.getArtifactHandler().getExtension();
|
| }
|
|
|
| /**
|
| * Copy file from source to destination only if source timestamp is later than the destination timestamp.
|
| * The directories up to <code>destination</code> will be created if they don't already exist.
|
| * <code>destination</code> will be overwritten if it already exists.
|
| *
|
| * @param source An existing non-directory <code>File</code> to copy bytes from.
|
| * @param destination A non-directory <code>File</code> to write bytes to (possibly
|
| * overwriting).
|
| * @throws IOException if <code>source</code> does not exist, <code>destination</code> cannot be
|
| * written to, or an IO error occurs during copying.
|
| * @throws java.io.FileNotFoundException if <code>destination</code> is a directory
|
| * <p/>
|
| * TO DO: Remove this method when Maven moves to plexus-utils version 1.4
|
| */
|
| private void copyFileIfModified( File source, File destination )
|
| throws IOException
|
| {
|
| // TO DO: Remove this method and use the method in WarFileUtils when Maven 2 changes
|
| // to plexus-utils 1.2.
|
| if ( destination.lastModified() < source.lastModified() )
|
| {
|
| FileUtils.copyFile( source.getCanonicalFile(), destination );
|
| // preserve timestamp
|
| destination.setLastModified( source.lastModified() );
|
| }
|
| }
|
| |
| private void copyFileSet( FileSet fileSet, File targetDirectory ) |
| throws IOException |
| { |
| File dir = fileSet.getDirectory(); |
| if ( dir == null ) |
| { |
| dir = baseDir; |
| } |
| File targetDir = targetDirectory; |
| if ( fileSet.getOutputDirectory() != null ) |
| { |
| targetDir = new File( targetDir, fileSet.getOutputDirectory() ); |
| } |
| if ( targetDir.equals( dir ) ) |
| { |
| return; |
| } |
| |
| DirectoryScanner ds = new DirectoryScanner(); |
| ds.setBasedir( dir ); |
| if ( !fileSet.isSkipDefaultExcludes() ) |
| { |
| ds.addDefaultExcludes(); |
| } |
| final String[] excludes = fileSet.getExcludes(); |
| if ( excludes != null ) |
| { |
| ds.setExcludes( excludes ); |
| } |
| final String[] includes = fileSet.getIncludes(); |
| if ( includes != null ) |
| { |
| ds.setIncludes( includes ); |
| } |
| ds.scan(); |
| String[] files = ds.getIncludedFiles(); |
| for ( int i = 0; i < files.length; i++ ) |
| { |
| File sourceFile = new File( dir, files[i] ); |
| File targetFile = new File( targetDir, files[i] ); |
| FileUtils.copyFile( sourceFile, targetFile ); |
| } |
| } |
| |
| |
| private void copyMetaInfFile( final File pSource, final File pTarget, |
| final boolean pExistsBeforeCopying, |
| final String pDescription ) |
| throws MojoExecutionException, IOException |
| { |
| if ( pSource != null && pTarget != null ) |
| { |
| if ( !pSource.exists() ) |
| { |
| throw new MojoExecutionException( "The configured " + pDescription + " could not be found at " |
| + pSource ); |
| } |
| |
| if ( !pExistsBeforeCopying && pTarget.exists() ) |
| { |
| getLog().warn( "The configured " + pDescription + " overwrites another file from the classpath." ); |
| } |
| |
| FileUtils.copyFile( pSource, pTarget ); |
| } |
| } |
| } |
