BundleAllPlugin xref

    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one
    3    * or more contributor license agreements.  See the NOTICE file
    4    * distributed with this work for additional information
    5    * regarding copyright ownership.  The ASF licenses this file
    6    * to you under the Apache License, Version 2.0 (the
    7    * "License"); you may not use this file except in compliance
    8    * with the License.  You may obtain a copy of the License at
    9    *
    10   *   http://www.apache.org/licenses/LICENSE-2.0
    11   *
    12   * Unless required by applicable law or agreed to in writing,
    13   * software distributed under the License is distributed on an
    14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    15   * KIND, either express or implied.  See the License for the
    16   * specific language governing permissions and limitations
    17   * under the License.
    18   */
    19  package org.apache.felix.bundleplugin;
    20
    21
    22  import java.io.File;
    23  import java.io.FilenameFilter;
    24  import java.util.Arrays;
    25  import java.util.Collection;
    26  import java.util.HashSet;
    27  import java.util.Iterator;
    28  import java.util.LinkedHashMap;
    29  import java.util.List;
    30  import java.util.Map;
    31  import java.util.Properties;
    32  import java.util.Set;
    33  import java.util.jar.Manifest;
    34  import java.util.regex.Matcher;
    35  import java.util.regex.Pattern;
    36
    37  import org.apache.maven.artifact.Artifact;
    38  import org.apache.maven.artifact.factory.ArtifactFactory;
    39  import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
    40  import org.apache.maven.artifact.repository.ArtifactRepository;
    41  import org.apache.maven.artifact.resolver.ArtifactCollector;
    42  import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
    43  import org.apache.maven.artifact.resolver.ArtifactResolutionException;
    44  import org.apache.maven.artifact.resolver.ArtifactResolver;
    45  import org.apache.maven.artifact.versioning.VersionRange;
    46  import org.apache.maven.plugin.MojoExecutionException;
    47  import org.apache.maven.project.MavenProject;
    48  import org.apache.maven.project.MavenProjectBuilder;
    49  import org.apache.maven.project.ProjectBuildingException;
    50  import org.apache.maven.project.artifact.InvalidDependencyVersionException;
    51  import org.apache.maven.shared.dependency.tree.DependencyNode;
    52  import org.apache.maven.shared.dependency.tree.DependencyTreeBuilder;
    53  import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException;
    54  import org.codehaus.plexus.util.FileUtils;
    55
    56  import aQute.bnd.osgi.Analyzer;
    57  import aQute.bnd.osgi.Jar;
    58
    59
    60  /**
    61   * Create OSGi bundles from all dependencies in the Maven project
    62   *
    63   * @goal bundleall
    64   * @phase package
    65   * @requiresDependencyResolution test
    66   * @description build an OSGi bundle jar for all transitive dependencies
    67   * @deprecated The bundleall goal is no longer supported and may be removed in a future release
    68   */
    69  @Deprecated
    70  public class BundleAllPlugin extends ManifestPlugin
    71  {
    72      private static final String LS = System.getProperty( "line.separator" );
    73
    74      private static final Pattern SNAPSHOT_VERSION_PATTERN = Pattern.compile( "[0-9]{8}_[0-9]{6}_[0-9]+" );
    75
    76      /**
    77       * Local repository.
    78       *
    79       * @parameter expression="${localRepository}"
    80       * @required
    81       * @readonly
    82       */
    83      private ArtifactRepository localRepository;
    84
    85      /**
    86       * Remote repositories.
    87       *
    88       * @parameter expression="${project.remoteArtifactRepositories}"
    89       * @required
    90       * @readonly
    91       */
    92      private List remoteRepositories;
    93
    94      /**
    95       * Import-Package to be used when wrapping dependencies.
    96       *
    97       * @parameter expression="${wrapImportPackage}" default-value="*"
    98       */
    99      private String wrapImportPackage;
    100
    101     /**
    102      * @component
    103      */
    104     private ArtifactFactory m_factory;
    105
    106     /**
    107      * @component
    108      */
    109     private ArtifactMetadataSource m_artifactMetadataSource;
    110
    111     /**
    112      * @component
    113      */
    114     private ArtifactCollector m_collector;
    115
    116     /**
    117      * Artifact resolver, needed to download jars.
    118      *
    119      * @component
    120      */
    121     private ArtifactResolver m_artifactResolver;
    122
    123     /**
    124      * @component
    125      */
    126     private DependencyTreeBuilder m_dependencyTreeBuilder;
    127
    128     /**
    129      * @component
    130      */
    131     private MavenProjectBuilder m_mavenProjectBuilder;
    132
    133     /**
    134      * Ignore missing artifacts that are not required by current project but are required by the
    135      * transitive dependencies.
    136      *
    137      * @parameter
    138      */
    139     private boolean ignoreMissingArtifacts;
    140
    141     private Set m_artifactsBeingProcessed = new HashSet();
    142
    143     /**
    144      * Process up to some depth
    145      *
    146      * @parameter
    147      */
    148     private int depth = Integer.MAX_VALUE;
    149
    150
    151     public void execute() throws MojoExecutionException
    152     {
    153         getLog().warn( "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" );
    154         getLog().warn( "! The bundleall goal is no longer supported and may be removed in a future release !" );
    155         getLog().warn( "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" );
    156
    157         BundleInfo bundleInfo = bundleAll( getProject() );
    158         logDuplicatedPackages( bundleInfo );
    159     }
    160
    161
    162     /**
    163      * Bundle a project and all its dependencies
    164      *
    165      * @param project
    166      * @throws MojoExecutionException
    167      */
    168     private BundleInfo bundleAll( MavenProject project ) throws MojoExecutionException
    169     {
    170         return bundleAll( project, depth );
    171     }
    172
    173
    174     /**
    175      * Bundle a project and its transitive dependencies up to some depth level
    176      *
    177      * @param project
    178      * @param maxDepth how deep to process the dependency tree
    179      * @throws MojoExecutionException
    180      */
    181     protected BundleInfo bundleAll( MavenProject project, int maxDepth ) throws MojoExecutionException
    182     {
    183         if ( alreadyBundled( project.getArtifact() ) )
    184         {
    185             getLog().debug( "Ignoring project already processed " + project.getArtifact() );
    186             return null;
    187         }
    188
    189         if ( m_artifactsBeingProcessed.contains( project.getArtifact() ) )
    190         {
    191             getLog().warn( "Ignoring artifact due to dependency cycle " + project.getArtifact() );
    192             return null;
    193         }
    194         m_artifactsBeingProcessed.add( project.getArtifact() );
    195
    196         DependencyNode dependencyTree;
    197
    198         try
    199         {
    200             dependencyTree = m_dependencyTreeBuilder.buildDependencyTree( project, localRepository, m_factory,
    201                 m_artifactMetadataSource, null, m_collector );
    202         }
    203         catch ( DependencyTreeBuilderException e )
    204         {
    205             throw new MojoExecutionException( "Unable to build dependency tree", e );
    206         }
    207
    208         BundleInfo bundleInfo = new BundleInfo();
    209
    210         if ( !dependencyTree.hasChildren() )
    211         {
    212             /* no need to traverse the tree */
    213             return bundleRoot( project, bundleInfo );
    214         }
    215
    216         getLog().debug( "Will bundle the following dependency tree" + LS + dependencyTree );
    217
    218         for ( Iterator it = dependencyTree.inverseIterator(); it.hasNext(); )
    219         {
    220             DependencyNode node = ( DependencyNode ) it.next();
    221             if ( !it.hasNext() )
    222             {
    223                 /* this is the root, current project */
    224                 break;
    225             }
    226
    227             if ( node.getState() != DependencyNode.INCLUDED )
    228             {
    229                 continue;
    230             }
    231
    232             if ( Artifact.SCOPE_SYSTEM.equals( node.getArtifact().getScope() ) )
    233             {
    234                 getLog().debug( "Ignoring system scoped artifact " + node.getArtifact() );
    235                 continue;
    236             }
    237
    238             Artifact artifact;
    239             try
    240             {
    241                 artifact = resolveArtifact( node.getArtifact() );
    242             }
    243             catch ( ArtifactNotFoundException e )
    244             {
    245                 if ( ignoreMissingArtifacts )
    246                 {
    247                     continue;
    248                 }
    249
    250                 throw new MojoExecutionException( "Artifact was not found in the repo" + node.getArtifact(), e );
    251             }
    252
    253             node.getArtifact().setFile( artifact.getFile() );
    254
    255             int nodeDepth = node.getDepth();
    256             if ( nodeDepth > maxDepth )
    257             {
    258                 /* node is deeper than we want */
    259                 getLog().debug(
    260                     "Ignoring " + node.getArtifact() + ", depth is " + nodeDepth + ", bigger than " + maxDepth );
    261                 continue;
    262             }
    263
    264             MavenProject childProject;
    265             try
    266             {
    267                 childProject = m_mavenProjectBuilder.buildFromRepository( artifact, remoteRepositories,
    268                     localRepository, true );
    269                 if ( childProject.getDependencyArtifacts() == null )
    270                 {
    271                     childProject.setDependencyArtifacts( childProject.createArtifacts( m_factory, null, null ) );
    272                 }
    273             }
    274             catch ( InvalidDependencyVersionException e )
    275             {
    276                 throw new MojoExecutionException( "Invalid dependency version for artifact " + artifact );
    277             }
    278             catch ( ProjectBuildingException e )
    279             {
    280                 throw new MojoExecutionException( "Unable to build project object for artifact " + artifact, e );
    281             }
    282
    283             childProject.setArtifact( artifact );
    284             getLog().debug( "Child project artifact location: " + childProject.getArtifact().getFile() );
    285
    286             if ( ( Artifact.SCOPE_COMPILE.equals( artifact.getScope() ) )
    287                 || ( Artifact.SCOPE_RUNTIME.equals( artifact.getScope() ) ) )
    288             {
    289                 BundleInfo subBundleInfo = bundleAll( childProject, maxDepth - 1 );
    290                 if ( subBundleInfo != null )
    291                 {
    292                     bundleInfo.merge( subBundleInfo );
    293                 }
    294             }
    295             else
    296             {
    297                 getLog().debug(
    298                     "Not processing due to scope (" + childProject.getArtifact().getScope() + "): "
    299                         + childProject.getArtifact() );
    300             }
    301         }
    302
    303         return bundleRoot( project, bundleInfo );
    304     }
    305
    306
    307     /**
    308      * Bundle the root of a dependency tree after all its children have been bundled
    309      *
    310      * @param project
    311      * @param bundleInfo
    312      * @return
    313      * @throws MojoExecutionException
    314      */
    315     private BundleInfo bundleRoot( MavenProject project, BundleInfo bundleInfo ) throws MojoExecutionException
    316     {
    317         /* do not bundle the project the mojo was called on */
    318         if ( getProject() != project )
    319         {
    320             getLog().debug( "Project artifact location: " + project.getArtifact().getFile() );
    321
    322             BundleInfo subBundleInfo = bundle( project );
    323             if ( subBundleInfo != null )
    324             {
    325                 bundleInfo.merge( subBundleInfo );
    326             }
    327         }
    328         return bundleInfo;
    329     }
    330
    331
    332     /**
    333      * Bundle one project only without building its childre
    334      *
    335      * @param project
    336      * @throws MojoExecutionException
    337      */
    338     protected BundleInfo bundle( MavenProject project ) throws MojoExecutionException
    339     {
    340         Artifact artifact = project.getArtifact();
    341         getLog().info( "Bundling " + artifact );
    342
    343         try
    344         {
    345             Map instructions = new LinkedHashMap();
    346             instructions.put( Analyzer.IMPORT_PACKAGE, wrapImportPackage );
    347
    348             project.getArtifact().setFile( getFile( artifact ) );
    349             File outputFile = getOutputFile( artifact );
    350
    351             if ( project.getArtifact().getFile().equals( outputFile ) )
    352             {
    353                 /* TODO find the cause why it's getting here */
    354                 return null;
    355                 //                getLog().error(
    356                 //                                "Trying to read and write " + artifact + " to the same file, try cleaning: "
    357                 //                                    + outputFile );
    358                 //                throw new IllegalStateException( "Trying to read and write " + artifact
    359                 //                    + " to the same file, try cleaning: " + outputFile );
    360             }
    361
    362             Analyzer analyzer = getAnalyzer( project, instructions, new Properties(), getClasspath( project ) );
    363
    364             Jar osgiJar = new Jar( project.getArtifactId(), project.getArtifact().getFile() );
    365
    366             outputFile.getAbsoluteFile().getParentFile().mkdirs();
    367
    368             Collection exportedPackages;
    369             if ( isOsgi( osgiJar ) )
    370             {
    371                 /* if it is already an OSGi jar copy it as is */
    372                 getLog().info(
    373                     "Using existing OSGi bundle for " + project.getGroupId() + ":" + project.getArtifactId() + ":"
    374                         + project.getVersion() );
    375                 String exportHeader = osgiJar.getManifest().getMainAttributes().getValue( Analyzer.EXPORT_PACKAGE );
    376                 exportedPackages = analyzer.parseHeader( exportHeader ).keySet();
    377                 FileUtils.copyFile( project.getArtifact().getFile(), outputFile );
    378             }
    379             else
    380             {
    381                 /* else generate the manifest from the packages */
    382                 exportedPackages = analyzer.getExports().keySet();
    383                 Manifest manifest = analyzer.getJar().getManifest();
    384                 osgiJar.setManifest( manifest );
    385                 osgiJar.write( outputFile );
    386             }
    387
    388             BundleInfo bundleInfo = addExportedPackages( project, exportedPackages );
    389
    390             // cleanup...
    391             analyzer.close();
    392             osgiJar.close();
    393
    394             return bundleInfo;
    395         }
    396         /* too bad Jar.write throws Exception */
    397         catch ( Exception e )
    398         {
    399             throw new MojoExecutionException( "Error generating OSGi bundle for project "
    400                 + getArtifactKey( project.getArtifact() ), e );
    401         }
    402     }
    403
    404
    405     private boolean isOsgi( Jar jar ) throws Exception
    406     {
    407         if ( jar.getManifest() != null )
    408         {
    409             return jar.getManifest().getMainAttributes().getValue( Analyzer.BUNDLE_NAME ) != null;
    410         }
    411         return false;
    412     }
    413
    414
    415     private BundleInfo addExportedPackages( MavenProject project, Collection packages )
    416     {
    417         BundleInfo bundleInfo = new BundleInfo();
    418         for ( Iterator it = packages.iterator(); it.hasNext(); )
    419         {
    420             String packageName = ( String ) it.next();
    421             bundleInfo.addExportedPackage( packageName, project.getArtifact() );
    422         }
    423         return bundleInfo;
    424     }
    425
    426
    427     private String getArtifactKey( Artifact artifact )
    428     {
    429         return artifact.getGroupId() + ":" + artifact.getArtifactId();
    430     }
    431
    432
    433     private String getBundleName( Artifact artifact )
    434     {
    435         return getMaven2OsgiConverter().getBundleFileName( artifact );
    436     }
    437
    438
    439     private boolean alreadyBundled( Artifact artifact )
    440     {
    441         return getBuiltFile( artifact ) != null;
    442     }
    443
    444
    445     /**
    446      * Use previously built bundles when available.
    447      *
    448      * @param artifact
    449      */
    450     protected File getFile( final Artifact artifact )
    451     {
    452         File bundle = getBuiltFile( artifact );
    453
    454         if ( bundle != null )
    455         {
    456             getLog().debug( "Using previously built OSGi bundle for " + artifact + " in " + bundle );
    457             return bundle;
    458         }
    459         return super.getFile( artifact );
    460     }
    461
    462
    463     private File getBuiltFile( final Artifact artifact )
    464     {
    465         File bundle = null;
    466
    467         /* if bundle was already built use it instead of jar from repo */
    468         File outputFile = getOutputFile( artifact );
    469         if ( outputFile.exists() )
    470         {
    471             bundle = outputFile;
    472         }
    473
    474         /*
    475          * Find snapshots in output folder, eg. 2.1-SNAPSHOT will match 2.1.0.20070207_193904_2
    476          * TODO there has to be another way to do this using Maven libs
    477          */
    478         if ( ( bundle == null ) && artifact.isSnapshot() )
    479         {
    480             final File buildDirectory = new File( getBuildDirectory() );
    481             if ( !buildDirectory.exists() )
    482             {
    483                 buildDirectory.mkdirs();
    484             }
    485             File[] files = buildDirectory.listFiles( new FilenameFilter()
    486             {
    487                 public boolean accept( File dir, String name )
    488                 {
    489                     if ( dir.equals( buildDirectory ) && snapshotMatch( artifact, name ) )
    490                     {
    491                         return true;
    492                     }
    493                     return false;
    494                 }
    495             } );
    496             if ( files.length > 1 )
    497             {
    498                 throw new RuntimeException( "More than one previously built bundle matches for artifact " + artifact
    499                     + " : " + Arrays.asList( files ) );
    500             }
    501             if ( files.length == 1 )
    502             {
    503                 bundle = files[0];
    504             }
    505         }
    506
    507         return bundle;
    508     }
    509
    510
    511     /**
    512      * Check that the bundleName provided correspond to the artifact provided.
    513      * Used to determine when the bundle name is a timestamped snapshot and the artifact is a snapshot not timestamped.
    514      *
    515      * @param artifact artifact with snapshot version
    516      * @param bundleName bundle file name
    517      * @return if both represent the same artifact and version, forgetting about the snapshot timestamp
    518      */
    519     protected boolean snapshotMatch( Artifact artifact, String bundleName )
    520     {
    521         String artifactBundleName = getBundleName( artifact );
    522         int i = artifactBundleName.indexOf( "SNAPSHOT" );
    523         if ( i < 0 )
    524         {
    525             return false;
    526         }
    527         artifactBundleName = artifactBundleName.substring( 0, i );
    528
    529         if ( bundleName.startsWith( artifactBundleName ) )
    530         {
    531             /* it's the same artifact groupId and artifactId */
    532             String timestamp = bundleName.substring( artifactBundleName.length(), bundleName.lastIndexOf( ".jar" ) );
    533             Matcher m = SNAPSHOT_VERSION_PATTERN.matcher( timestamp );
    534             return m.matches();
    535         }
    536         return false;
    537     }
    538
    539
    540     protected File getOutputFile( Artifact artifact )
    541     {
    542         return new File( getOutputDirectory(), getBundleName( artifact ) );
    543     }
    544
    545
    546     private Artifact resolveArtifact( Artifact artifact ) throws MojoExecutionException, ArtifactNotFoundException
    547     {
    548         VersionRange versionRange;
    549         if ( artifact.getVersion() != null )
    550         {
    551             versionRange = VersionRange.createFromVersion( artifact.getVersion() );
    552         }
    553         else
    554         {
    555             versionRange = artifact.getVersionRange();
    556         }
    557
    558         /*
    559          * there's a bug with ArtifactFactory#createDependencyArtifact(String, String, VersionRange,
    560          * String, String, String) that ignores the scope parameter, that's why we use the one with
    561          * the extra null parameter
    562          */
    563         Artifact resolvedArtifact = m_factory.createDependencyArtifact( artifact.getGroupId(),
    564             artifact.getArtifactId(), versionRange, artifact.getType(), artifact.getClassifier(), artifact.getScope(),
    565             null );
    566
    567         try
    568         {
    569             m_artifactResolver.resolve( resolvedArtifact, remoteRepositories, localRepository );
    570         }
    571         catch ( ArtifactResolutionException e )
    572         {
    573             throw new MojoExecutionException( "Error resolving artifact " + resolvedArtifact, e );
    574         }
    575
    576         return resolvedArtifact;
    577     }
    578
    579
    580     /**
    581      * Log what packages are exported in more than one bundle
    582      */
    583     protected void logDuplicatedPackages( BundleInfo bundleInfo )
    584     {
    585         Map duplicatedExports = bundleInfo.getDuplicatedExports();
    586
    587         for ( Iterator it = duplicatedExports.entrySet().iterator(); it.hasNext(); )
    588         {
    589             Map.Entry entry = ( Map.Entry ) it.next();
    590             String packageName = ( String ) entry.getKey();
    591             Collection artifacts = ( Collection ) entry.getValue();
    592
    593             getLog().warn( "Package " + packageName + " is exported in more than a bundle: " );
    594             for ( Iterator it2 = artifacts.iterator(); it2.hasNext(); )
    595             {
    596                 Artifact artifact = ( Artifact ) it2.next();
    597                 getLog().warn( "  " + artifact );
    598             }
    599
    600         }
    601     }
    602 }