View Javadoc

1   package org.apache.maven.plugin.ear;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import org.apache.maven.artifact.Artifact;
23  import org.apache.maven.artifact.resolver.filter.ScopeArtifactFilter;
24  import org.apache.maven.plugin.AbstractMojo;
25  import org.apache.maven.plugin.MojoExecutionException;
26  import org.apache.maven.plugin.MojoFailureException;
27  import org.apache.maven.plugin.ear.util.ArtifactTypeMappingService;
28  import org.apache.maven.project.MavenProject;
29  import org.codehaus.plexus.configuration.PlexusConfiguration;
30  import org.codehaus.plexus.configuration.PlexusConfigurationException;
31  
32  import java.io.File;
33  import java.util.ArrayList;
34  import java.util.Iterator;
35  import java.util.List;
36  import java.util.Set;
37  
38  /**
39   * A base class for EAR-processing related tasks.
40   *
41   * @author <a href="snicoll@apache.org">Stephane Nicoll</a>
42   * @version $Id: AbstractEarMojo.java 905071 2010-01-31 16:50:13Z snicoll $
43   */
44  public abstract class AbstractEarMojo
45      extends AbstractMojo
46  {
47  
48      public static final String VERSION_1_3 = "1.3";
49  
50      public static final String VERSION_1_4 = "1.4";
51  
52      public static final String VERSION_5 = "5";
53  
54      public static final String VERSION_6 = "6";
55  
56      public static final String APPLICATION_XML_URI = "META-INF/application.xml";
57  
58      public static final String META_INF = "META-INF";
59  
60      public static final String UTF_8 = "UTF-8";
61  
62      /**
63       * The version of the application.xml to generate. Valid values
64       * are 1.3, 1.4, 5 and 6.
65       *
66       * @parameter default-value="1.3"
67       */
68      protected String version;
69  
70      /**
71       * Character encoding for the auto-generated deployment file(s).
72       *
73       * @parameter default-value="UTF-8"
74       */
75      protected String encoding;
76  
77      /**
78       * Directory where the deployment descriptor file(s) will be auto-generated.
79       *
80       * @parameter expression="${project.build.directory}"
81       */
82      protected String generatedDescriptorLocation;
83  
84      /**
85       * The maven project.
86       *
87       * @parameter expression="${project}"
88       * @required
89       * @readonly
90       */
91      protected MavenProject project;
92  
93      /**
94       * The ear modules configuration.
95       *
96       * @parameter
97       */
98      private EarModule[] modules;
99  
100     /**
101      * The artifact type mappings.
102      *
103      * @parameter
104      */
105     protected PlexusConfiguration artifactTypeMappings;
106 
107     /**
108      * The default bundle dir for libraries.
109      *
110      * @parameter alias="defaultJavaBundleDir"
111      */
112     protected String defaultLibBundleDir;
113 
114     /**
115      * Should libraries be added in application.xml
116      *
117      * @parameter default-value="false"
118      */
119     private Boolean includeLibInApplicationXml = Boolean.FALSE;
120 
121     /**
122      * The file name mapping to use for all dependencies included
123      * in the EAR file.
124      *
125      * @parameter
126      */
127     private String fileNameMapping;
128 
129     /**
130      * Directory that resources are copied to during the build.
131      *
132      * @parameter expression="${project.build.directory}/${project.build.finalName}"
133      * @required
134      */
135     private File workDirectory;
136 
137     /**
138      * The JBoss specific configuration.
139      *
140      * @parameter
141      */
142     private PlexusConfiguration jboss;
143 
144     /**
145      * The id to use to define the main artifact (e.g. the artifact without
146      * a classifier) when there is multiple candidates.
147      *
148      * @parameter
149      */
150     private String mainArtifactId = "none";
151 
152     private List earModules;
153 
154     private List allModules;
155 
156     private JbossConfiguration jbossConfiguration;
157 
158     public void execute()
159         throws MojoExecutionException, MojoFailureException
160     {
161         getLog().debug( "Resolving artifact type mappings ..." );
162         try
163         {
164             ArtifactTypeMappingService.getInstance().configure( artifactTypeMappings );
165         }
166         catch ( EarPluginException e )
167         {
168             throw new MojoExecutionException( "Failed to initialize artifact type mappings", e );
169         }
170         catch ( PlexusConfigurationException e )
171         {
172             throw new MojoExecutionException( "Invalid artifact type mappings configuration", e );
173         }
174 
175         getLog().debug( "Initializing JBoss configuration if necessary ..." );
176         try
177         {
178             initializeJbossConfiguration();
179         }
180         catch ( EarPluginException e )
181         {
182             throw new MojoExecutionException( "Failed to initialize JBoss configuration", e );
183         }
184 
185         getLog().debug( "Initializing ear execution context" );
186         EarExecutionContext.getInstance().initialize( project, mainArtifactId, defaultLibBundleDir, jbossConfiguration,
187                                                       fileNameMapping );
188 
189         getLog().debug( "Resolving ear modules ..." );
190         allModules = new ArrayList();
191         try
192         {
193             if ( modules != null && modules.length > 0 )
194             {
195                 // Let's validate user-defined modules
196                 EarModule module = null;
197 
198                 for ( int i = 0; i < modules.length; i++ )
199                 {
200                     module = modules[i];
201                     getLog().debug( "Resolving ear module[" + module + "]" );
202                     module.resolveArtifact( project.getArtifacts() );
203                     allModules.add( module );
204                 }
205             }
206 
207             // Let's add other modules
208             Set artifacts = project.getArtifacts();
209             for ( Iterator iter = artifacts.iterator(); iter.hasNext(); )
210             {
211                 Artifact artifact = (Artifact) iter.next();
212 
213                 // If the artifact's type is POM, ignore and continue
214                 // since it's used for transitive deps only.
215                 if ( "pom".equals( artifact.getType() ) )
216                 {
217                     continue;
218                 }
219 
220                 // Artifact is not yet registered and it has neither test, nor a
221                 // provided scope, not is it optional
222                 ScopeArtifactFilter filter = new ScopeArtifactFilter( Artifact.SCOPE_RUNTIME );
223                 if ( !isArtifactRegistered( artifact, allModules ) && !artifact.isOptional() &&
224                     filter.include( artifact ) )
225                 {
226                     EarModule module = EarModuleFactory.newEarModule( artifact, version, defaultLibBundleDir,
227                                                                       includeLibInApplicationXml );
228                     allModules.add( module );
229                 }
230             }
231         }
232         catch ( EarPluginException e )
233         {
234             throw new MojoExecutionException( "Failed to initialize ear modules", e );
235         }
236 
237         // Now we have everything let's built modules which have not been excluded
238         earModules = new ArrayList();
239         for ( Iterator iter = allModules.iterator(); iter.hasNext(); )
240         {
241             EarModule earModule = (EarModule) iter.next();
242             if ( earModule.isExcluded() )
243             {
244                 getLog().debug( "Skipping ear module[" + earModule + "]" );
245             }
246             else
247             {
248                 earModules.add( earModule );
249             }
250         }
251 
252     }
253 
254     protected List getModules()
255     {
256         if ( earModules == null )
257         {
258             throw new IllegalStateException( "Ear modules have not been initialized" );
259         }
260         return earModules;
261     }
262 
263     protected MavenProject getProject()
264     {
265         return project;
266     }
267 
268     protected File getWorkDirectory()
269     {
270         return workDirectory;
271     }
272 
273     protected JbossConfiguration getJbossConfiguration()
274     {
275         return jbossConfiguration;
276     }
277 
278     private static boolean isArtifactRegistered( Artifact a, List currentList )
279     {
280         Iterator i = currentList.iterator();
281         while ( i.hasNext() )
282         {
283             EarModule em = (EarModule) i.next();
284             if ( em.getArtifact().equals( a ) )
285             {
286                 return true;
287             }
288         }
289         return false;
290     }
291 
292     /**
293      * Initializes the JBoss configuration.
294      *
295      * @throws EarPluginException if the configuration is invalid
296      */
297     private void initializeJbossConfiguration()
298         throws EarPluginException
299     {
300         if ( jboss == null )
301         {
302             jbossConfiguration = null;
303         }
304         else
305         {
306             try
307             {
308                 String version = jboss.getChild( JbossConfiguration.VERSION ).getValue();
309                 if ( version == null )
310                 {
311                     getLog().info( "JBoss version not set, using JBoss 4 by default" );
312                     version = JbossConfiguration.VERSION_4;
313                 }
314                 final String securityDomain = jboss.getChild( JbossConfiguration.SECURITY_DOMAIN ).getValue();
315                 final String unauthenticatedPrincipal =
316                     jboss.getChild( JbossConfiguration.UNAUHTHENTICTED_PRINCIPAL ).getValue();
317 
318                 final PlexusConfiguration loaderRepositoryEl = jboss.getChild( JbossConfiguration.LOADER_REPOSITORY );
319                 final String loaderRepository = loaderRepositoryEl.getValue();
320                 final String loaderRepositoryClass =
321                     loaderRepositoryEl.getAttribute( JbossConfiguration.LOADER_REPOSITORY_CLASS_ATTRIBUTE );
322                 final PlexusConfiguration loaderRepositoryConfigEl =
323                     jboss.getChild( JbossConfiguration.LOADER_REPOSITORY_CONFIG );
324                 final String loaderRepositoryConfig = loaderRepositoryConfigEl.getValue();
325                 final String configParserClass =
326                     loaderRepositoryConfigEl.getAttribute( JbossConfiguration.CONFIG_PARSER_CLASS_ATTRIBUTE );
327 
328                 final String jmxName = jboss.getChild( JbossConfiguration.JMX_NAME ).getValue();
329                 final String moduleOrder = jboss.getChild( JbossConfiguration.MODULE_ORDER ).getValue();
330 
331                 final List dataSources = new ArrayList();
332                 final PlexusConfiguration dataSourcesEl = jboss.getChild( JbossConfiguration.DATASOURCES );
333                 if ( dataSourcesEl != null )
334                 {
335 
336                     final PlexusConfiguration[] dataSourcesConfig =
337                         dataSourcesEl.getChildren( JbossConfiguration.DATASOURCE );
338                     for ( int i = 0; i < dataSourcesConfig.length; i++ )
339                     {
340                         PlexusConfiguration dataSourceConfig = dataSourcesConfig[i];
341                         dataSources.add( dataSourceConfig.getValue() );
342 
343                     }
344                 }
345                 final String libraryDirectory = jboss.getChild( JbossConfiguration.LIBRARY_DIRECTORY ).getValue();
346                 jbossConfiguration = new JbossConfiguration( version, securityDomain, unauthenticatedPrincipal, jmxName,
347                                                              loaderRepository, moduleOrder, dataSources,
348                                                              libraryDirectory, loaderRepositoryConfig,
349                                                              loaderRepositoryClass, configParserClass );
350             }
351             catch ( PlexusConfigurationException e )
352             {
353                 throw new EarPluginException( "Invalid JBoss configuration", e );
354             }
355         }
356     }
357 }