1 package org.apache.maven.plugin.ejb;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.io.File;
23 import java.io.IOException;
24 import java.util.List;
25
26 import org.apache.commons.io.IOUtils;
27 import org.apache.commons.io.input.XmlStreamReader;
28 import org.apache.maven.archiver.MavenArchiveConfiguration;
29 import org.apache.maven.archiver.MavenArchiver;
30 import org.apache.maven.artifact.DependencyResolutionRequiredException;
31 import org.apache.maven.execution.MavenSession;
32 import org.apache.maven.plugin.AbstractMojo;
33 import org.apache.maven.plugin.MojoExecutionException;
34 import org.apache.maven.plugins.annotations.Component;
35 import org.apache.maven.plugins.annotations.LifecyclePhase;
36 import org.apache.maven.plugins.annotations.Mojo;
37 import org.apache.maven.plugins.annotations.Parameter;
38 import org.apache.maven.plugins.annotations.ResolutionScope;
39 import org.apache.maven.project.MavenProject;
40 import org.apache.maven.project.MavenProjectHelper;
41 import org.apache.maven.shared.filtering.MavenFileFilter;
42 import org.apache.maven.shared.filtering.MavenFilteringException;
43 import org.apache.maven.shared.filtering.MavenResourcesExecution;
44 import org.apache.maven.shared.utils.io.FileUtils.FilterWrapper;
45 import org.codehaus.plexus.archiver.Archiver;
46 import org.codehaus.plexus.archiver.ArchiverException;
47 import org.codehaus.plexus.archiver.jar.JarArchiver;
48 import org.codehaus.plexus.archiver.jar.ManifestException;
49 import org.codehaus.plexus.util.FileUtils;
50
51
52
53
54
55
56
57 @Mojo( name = "ejb", requiresDependencyResolution = ResolutionScope.RUNTIME, threadSafe = true, defaultPhase = LifecyclePhase.PACKAGE )
58 public class EjbMojo
59 extends AbstractMojo
60 {
61
62 private static final String[] DEFAULT_INCLUDES = new String[] { "**/**" };
63
64 private static final String[] DEFAULT_CLIENT_EXCLUDES = new String[] { "**/*Bean.class", "**/*CMP.class",
65 "**/*Session.class", "**/package.html" };
66
67
68
69
70 @Parameter( defaultValue = "${project.build.directory}", required = true, readonly = true )
71 private File basedir;
72
73
74
75
76 @Parameter( property = "outputDirectory", defaultValue = "${project.build.outputDirectory}" )
77 private File outputDirectory;
78
79
80
81
82 @Parameter( property = "jarName", defaultValue = "${project.build.finalName}" )
83 private String jarName;
84
85
86
87
88 @Parameter( property = "ejb.classifier" )
89 private String classifier;
90
91
92
93
94 @Parameter( property = "ejb.ejbJar", defaultValue = "META-INF/ejb-jar.xml" )
95
96 private String ejbJar = "META-INF/ejb-jar.xml";
97
98
99
100
101 @Parameter( property = "ejb.generateClient", defaultValue = "false" )
102 private boolean generateClient;
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119 @Parameter
120 private List<String> clientExcludes;
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136 @Parameter
137 private List<String> clientIncludes;
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153 @Parameter
154 private List<String> excludes;
155
156
157
158
159 @Parameter( defaultValue = "${project}", readonly = true, required = true )
160 private MavenProject project;
161
162
163
164
165 @Component( role = Archiver.class, hint = "jar" )
166 private JarArchiver jarArchiver;
167
168
169
170
171
172
173
174
175
176
177
178
179
180 @Parameter( property = "ejb.ejbVersion", defaultValue = "2.1" )
181 private String ejbVersion;
182
183
184
185
186 @Component( role = Archiver.class, hint = "jar" )
187 private JarArchiver clientJarArchiver;
188
189
190
191
192 @Component
193 private MavenProjectHelper projectHelper;
194
195
196
197
198
199 @Parameter
200 private MavenArchiveConfiguration archive = new MavenArchiveConfiguration();
201
202
203
204
205
206
207 @Parameter( property = "ejb.escapeBackslashesInFilePath", defaultValue = "false" )
208 private boolean escapeBackslashesInFilePath;
209
210
211
212
213
214
215 @Parameter( property = "ejb.escapeString" )
216 protected String escapeString;
217
218
219
220
221
222
223 @Parameter( property = "ejb.filterDeploymentDescriptor", defaultValue = "false" )
224 private boolean filterDeploymentDescriptor;
225
226
227
228
229
230
231 @Parameter
232 private List filters;
233
234
235
236
237 @Component( role = MavenFileFilter.class, hint = "default" )
238 private MavenFileFilter mavenFileFilter;
239
240
241
242
243 @Parameter( defaultValue = "${session}", readonly = true, required = true )
244 private MavenSession session;
245
246
247
248
249
250
251 public void execute()
252 throws MojoExecutionException
253 {
254
255 if ( !outputDirectory.exists() )
256 {
257 getLog().warn( "The created EJB jar will be empty cause the " + outputDirectory.getPath()
258 + " did not exist." );
259 outputDirectory.mkdirs();
260 }
261
262 if ( getLog().isInfoEnabled() )
263 {
264 getLog().info( "Building EJB " + jarName + " with EJB version " + ejbVersion );
265 }
266
267 File jarFile = getEJBJarFile( basedir, jarName, classifier );
268
269 MavenArchiver archiver = new MavenArchiver();
270
271 archiver.setArchiver( jarArchiver );
272
273 archiver.setOutputFile( jarFile );
274
275 File deploymentDescriptor = new File( outputDirectory, ejbJar );
276
277
278 if ( !ejbVersion.matches( "\\A[2-3]\\.[0-9]\\z" ) )
279 {
280 throw new MojoExecutionException( "ejbVersion is not valid: " + ejbVersion
281 + ". Must be 2.x or 3.x (where x is a digit)" );
282 }
283
284 if ( ejbVersion.matches( "\\A2\\.[0-9]\\z" ) && !deploymentDescriptor.exists() )
285 {
286 throw new MojoExecutionException( "Error assembling EJB: " + ejbJar + " is required for ejbVersion 2.x" );
287 }
288
289 try
290 {
291
292 String[] mainJarExcludes = new String[] { ejbJar, "**/package.html" };
293
294 if ( excludes != null && !excludes.isEmpty() )
295 {
296 excludes.add( ejbJar );
297 mainJarExcludes = (String[]) excludes.toArray( new String[excludes.size()] );
298 }
299
300 archiver.getArchiver().addDirectory( outputDirectory, DEFAULT_INCLUDES, mainJarExcludes );
301
302 if ( deploymentDescriptor.exists() )
303 {
304
305 if ( filterDeploymentDescriptor )
306 {
307 getLog().debug( "Filtering deployment descriptor." );
308 MavenResourcesExecution mavenResourcesExecution = new MavenResourcesExecution();
309 mavenResourcesExecution.setEscapeString( escapeString );
310 List<FilterWrapper> filterWrappers =
311 mavenFileFilter.getDefaultFilterWrappers( project, filters, escapeBackslashesInFilePath,
312 this.session, mavenResourcesExecution );
313
314
315 File unfilteredDeploymentDescriptor = new File( outputDirectory, ejbJar + ".unfiltered" );
316 FileUtils.copyFile( deploymentDescriptor, unfilteredDeploymentDescriptor );
317 mavenFileFilter.copyFile( unfilteredDeploymentDescriptor, deploymentDescriptor, true,
318 filterWrappers, getEncoding( unfilteredDeploymentDescriptor ) );
319
320 FileUtils.forceDelete( unfilteredDeploymentDescriptor );
321 }
322 archiver.getArchiver().addFile( deploymentDescriptor, ejbJar );
323 }
324
325
326 archiver.createArchive( session, project, archive );
327 }
328 catch ( ArchiverException e )
329 {
330 throw new MojoExecutionException( "There was a problem creating the EJB archive: " + e.getMessage(), e );
331 }
332 catch ( ManifestException e )
333 {
334 throw new MojoExecutionException( "There was a problem creating the EJB archive: " + e.getMessage(), e );
335 }
336 catch ( IOException e )
337 {
338 throw new MojoExecutionException( "There was a problem creating the EJB archive: " + e.getMessage(), e );
339 }
340 catch ( DependencyResolutionRequiredException e )
341 {
342 throw new MojoExecutionException( "There was a problem creating the EJB archive: " + e.getMessage(), e );
343 }
344 catch ( MavenFilteringException e )
345 {
346 throw new MojoExecutionException( "There was a problem filtering the deployment descriptor: "
347 + e.getMessage(), e );
348 }
349
350
351 if ( classifier != null )
352 {
353 projectHelper.attachArtifact( project, "ejb", classifier, jarFile );
354 }
355 else
356 {
357 project.getArtifact().setFile( jarFile );
358 }
359
360 if ( generateClient )
361 {
362 String clientJarName = jarName;
363 if ( classifier != null )
364 {
365 clientJarName += "-" + classifier;
366 }
367
368 getLog().info( "Building EJB client " + clientJarName + "-client" );
369
370 String[] excludes = DEFAULT_CLIENT_EXCLUDES;
371 String[] includes = DEFAULT_INCLUDES;
372
373 if ( clientIncludes != null && !clientIncludes.isEmpty() )
374 {
375 includes = (String[]) clientIncludes.toArray( new String[clientIncludes.size()] );
376 }
377
378 if ( clientExcludes != null && !clientExcludes.isEmpty() )
379 {
380 excludes = (String[]) clientExcludes.toArray( new String[clientExcludes.size()] );
381 }
382
383 File clientJarFile = new File( basedir, clientJarName + "-client.jar" );
384
385 MavenArchiver clientArchiver = new MavenArchiver();
386
387 clientArchiver.setArchiver( clientJarArchiver );
388
389 clientArchiver.setOutputFile( clientJarFile );
390
391 try
392 {
393 clientArchiver.getArchiver().addDirectory( outputDirectory, includes, excludes );
394
395
396 clientArchiver.createArchive( session, project, archive );
397
398 }
399 catch ( ArchiverException e )
400 {
401 throw new MojoExecutionException( "There was a problem creating the EJB client archive: "
402 + e.getMessage(), e );
403 }
404 catch ( ManifestException e )
405 {
406 throw new MojoExecutionException( "There was a problem creating the EJB client archive: "
407 + e.getMessage(), e );
408 }
409 catch ( IOException e )
410 {
411 throw new MojoExecutionException( "There was a problem creating the EJB client archive: "
412 + e.getMessage(), e );
413 }
414 catch ( DependencyResolutionRequiredException e )
415 {
416 throw new MojoExecutionException( "There was a problem creating the EJB client archive: "
417 + e.getMessage(), e );
418 }
419
420
421 if ( classifier != null )
422 {
423 projectHelper.attachArtifact( project, "ejb-client", classifier + "-client", clientJarFile );
424 }
425 else
426 {
427 projectHelper.attachArtifact( project, "ejb-client", "client", clientJarFile );
428 }
429 }
430 }
431
432
433
434
435
436
437
438
439
440 private static File getEJBJarFile( File basedir, String finalName, String classifier )
441 {
442 if ( classifier == null )
443 {
444 classifier = "";
445 }
446 else if ( classifier.trim().length() > 0 && !classifier.startsWith( "-" ) )
447 {
448 classifier = "-" + classifier;
449 }
450
451 return new File( basedir, finalName + classifier + ".jar" );
452 }
453
454
455
456
457
458
459
460
461 private String getEncoding( File xmlFile )
462 throws IOException
463 {
464 XmlStreamReader xmlReader = null;
465 try
466 {
467 xmlReader = new XmlStreamReader( xmlFile );
468 return xmlReader.getEncoding();
469 }
470 finally
471 {
472 IOUtils.closeQuietly( xmlReader );
473 }
474 }
475
476 }