KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > servicemix > maven > plugin > jbi > GenerateServiceAssemblyDescriptorMojo


1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License. You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */

17 package org.apache.servicemix.maven.plugin.jbi;
18
19 import java.io.File JavaDoc;
20 import java.io.FileReader JavaDoc;
21 import java.io.IOException JavaDoc;
22 import java.util.ArrayList JavaDoc;
23 import java.util.Iterator JavaDoc;
24 import java.util.List JavaDoc;
25 import java.util.Set JavaDoc;
26
27 import org.apache.maven.artifact.Artifact;
28 import org.apache.maven.artifact.resolver.filter.ScopeArtifactFilter;
29 import org.apache.maven.model.Dependency;
30 import org.apache.maven.model.Model;
31 import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
32 import org.apache.maven.plugin.MojoExecutionException;
33 import org.apache.maven.plugin.MojoFailureException;
34 import org.apache.maven.project.MavenProject;
35 import org.apache.maven.project.ProjectBuildingException;
36 import org.codehaus.plexus.util.FileUtils;
37
38 /**
39  * A Mojo used to build the jbi.xml file for a service unit.
40  *
41  * @author <a HREF="pdodds@apache.org">Philip Dodds</a>
42  * @version $Id: GenerateComponentDescriptorMojo 314956 2005-10-12 16:27:15Z
43  * brett $
44  * @goal generate-jbi-service-assembly-descriptor
45  * @phase generate-resources
46  * @requiresDependencyResolution runtime
47  * @description generates the jbi.xml deployment descriptor for a service unit
48  */

49 public class GenerateServiceAssemblyDescriptorMojo extends AbstractJbiMojo {
50
51     public static final String JavaDoc UTF_8 = "UTF-8";
52
53     /**
54      * Whether the jbi.xml should be generated or not.
55      *
56      * @parameter
57      */

58     private Boolean JavaDoc generateJbiDescriptor = Boolean.TRUE;
59
60     /**
61      * The component name.
62      *
63      * @parameter expression="${project.artifactId}"
64      */

65     private String JavaDoc name;
66
67     /**
68      * The component description.
69      *
70      * @parameter expression="${project.name}"
71      */

72     private String JavaDoc description;
73
74     /**
75      * Character encoding for the auto-generated application.xml file.
76      *
77      * @parameter
78      */

79     private String JavaDoc encoding = UTF_8;
80
81     /**
82      * Directory where the application.xml file will be auto-generated.
83      *
84      * @parameter expression="${project.build.directory}/classes/META-INF"
85      */

86     private String JavaDoc generatedDescriptorLocation;
87
88     /**
89      * Dependency graph
90      */

91     private JbiResolutionListener listener;
92
93     public void execute() throws MojoExecutionException, MojoFailureException {
94
95         getLog()
96                 .debug(
97                         " ======= GenerateServiceAssemlbyDescriptorMojo settings =======");
98         getLog().debug("workDirectory[" + workDirectory + "]");
99         getLog().debug("generateJbiDescriptor[" + generateJbiDescriptor + "]");
100         getLog().debug("name[" + name + "]");
101         getLog().debug("description[" + description + "]");
102         getLog().debug("encoding[" + encoding + "]");
103         getLog().debug(
104                 "generatedDescriptorLocation[" + generatedDescriptorLocation
105                         + "]");
106
107         if (!generateJbiDescriptor.booleanValue()) {
108             getLog().debug("Generation of jbi.xml is disabled");
109             return;
110         }
111
112         // Generate jbi descriptor and copy it to the build directory
113
getLog().info("Generating jbi.xml");
114         try {
115             listener = resolveProject();
116             generateJbiDescriptor();
117         } catch (JbiPluginException e) {
118             throw new MojoExecutionException("Failed to generate jbi.xml", e);
119         }
120
121         try {
122             FileUtils.copyFileToDirectory(new File JavaDoc(generatedDescriptorLocation,
123                     JBI_DESCRIPTOR), new File JavaDoc(getWorkDirectory(), META_INF));
124         } catch (IOException JavaDoc e) {
125             throw new MojoExecutionException(
126                     "Unable to copy jbi.xml to final destination", e);
127         }
128     }
129
130     /**
131      * Generates the deployment descriptor if necessary.
132      *
133      * @throws MojoExecutionException
134      */

135     protected void generateJbiDescriptor() throws JbiPluginException,
136             MojoExecutionException {
137         File JavaDoc outputDir = new File JavaDoc(generatedDescriptorLocation);
138         if (!outputDir.exists()) {
139             outputDir.mkdirs();
140         }
141
142         File JavaDoc descriptor = new File JavaDoc(outputDir, JBI_DESCRIPTOR);
143
144         List JavaDoc serviceUnits = new ArrayList JavaDoc();
145
146         Set JavaDoc artifacts = project.getArtifacts();
147         for (Iterator JavaDoc iter = artifacts.iterator(); iter.hasNext();) {
148             Artifact artifact = (Artifact) iter.next();
149
150             // TODO: utilise appropriate methods from project builder
151
ScopeArtifactFilter filter = new ScopeArtifactFilter(
152                     Artifact.SCOPE_RUNTIME);
153             if (!artifact.isOptional() && filter.include(artifact)
154                     && (artifact.getDependencyTrail().size() == 2)) {
155                 MavenProject project = null;
156                 try {
157                     project = projectBuilder.buildFromRepository(artifact,
158                             remoteRepos, localRepo);
159                 } catch (ProjectBuildingException e) {
160                     getLog().warn(
161                             "Unable to determine packaging for dependency : "
162                                     + artifact.getArtifactId()
163                                     + " assuming jar");
164                 }
165                 if ((project != null)
166                         && (project.getPackaging().equals("jbi-service-unit"))) {
167                     DependencyInformation info = new DependencyInformation();
168                     info.setName(artifact.getArtifactId());
169                     String JavaDoc name = artifact.getFile().getName();
170                     name = name.substring(0, name.lastIndexOf('.')) + ".zip";
171                     info.setFilename(name);
172                     info.setComponent(getComponentName(project, artifacts,
173                             artifact));
174                     info.setDescription(project.getDescription());
175                     serviceUnits.add(info);
176                 }
177
178             }
179         }
180
181         List JavaDoc orderedServiceUnits = reorderServiceUnits(serviceUnits);
182
183         JbiServiceAssemblyDescriptorWriter writer = new JbiServiceAssemblyDescriptorWriter(
184                 encoding);
185         writer.write(descriptor, name, description, orderedServiceUnits);
186     }
187
188     /**
189      * Re-orders the service units to match order in the dependencies section of
190      * the pom
191      *
192      * @param serviceUnits
193      * @throws MojoExecutionException
194      */

195     private List JavaDoc reorderServiceUnits(List JavaDoc serviceUnits)
196             throws MojoExecutionException {
197
198         // TODO Currently we get the model back by re-parsing it however in the
199
// future we should be able to use the getModel() - there should be a
200
// fix post 2.0.4
201

202         // Iterator dependencies =
203
// project.getModel().getDependencies().iterator();
204

205         // For now we will need to reparse the pom without processing
206
Iterator JavaDoc dependencies = getReparsedDependencies();
207         
208         List JavaDoc orderedServiceUnits = new ArrayList JavaDoc();
209         while (dependencies.hasNext()) {
210             Dependency dependency = (Dependency) dependencies.next();
211             for (Iterator JavaDoc it = serviceUnits.iterator(); it.hasNext();) {
212                 DependencyInformation serviceUnitInfo = (DependencyInformation) it
213                         .next();
214                 if (dependency.getArtifactId()
215                         .equals(serviceUnitInfo.getName())) {
216                     System.out.println("Adding "
217                             + serviceUnitInfo.getFilename());
218                     orderedServiceUnits.add(serviceUnitInfo);
219                 }
220
221             }
222         }
223
224         return orderedServiceUnits;
225     }
226
227     private Iterator JavaDoc getReparsedDependencies() throws MojoExecutionException {
228         MavenXpp3Reader mavenXpp3Reader = new MavenXpp3Reader();
229         try {
230             Model model = mavenXpp3Reader.read(new FileReader JavaDoc(new File JavaDoc(project
231                     .getBasedir(), "pom.xml")), false);
232             return model.getDependencies().iterator();
233         } catch (Exception JavaDoc e) {
234             throw new MojoExecutionException("Unable to reparse the pom.xml");
235         }
236     }
237
238     private String JavaDoc getComponentName(MavenProject project, Set JavaDoc artifacts,
239             Artifact suArtifact) throws MojoExecutionException {
240
241         getLog().info(
242                 "Determining component name for service unit "
243                         + project.getArtifactId());
244         if (project.getProperties().getProperty("componentName") != null) {
245             return project.getProperties().getProperty("componentName");
246         }
247
248         JbiResolutionListener.Node n = listener.getNode(suArtifact);
249         for (Iterator JavaDoc it = n.getChildren().iterator(); it.hasNext();) {
250             JbiResolutionListener.Node child = (JbiResolutionListener.Node) it
251                     .next();
252             MavenProject artifactProject = null;
253             try {
254                 artifactProject = projectBuilder.buildFromRepository(child
255                         .getArtifact(), remoteRepos, localRepo);
256             } catch (ProjectBuildingException e) {
257                 getLog().warn(
258                         "Unable to determine packaging for dependency : "
259                                 + child.getArtifact().getArtifactId()
260                                 + " assuming jar");
261             }
262             getLog().info(
263                     "Project " + artifactProject + " packaged "
264                             + artifactProject.getPackaging());
265             if ((artifactProject != null)
266                     && (artifactProject.getPackaging().equals("jbi-component"))) {
267                 return child.getArtifact().getArtifactId();
268             }
269         }
270
271         throw new MojoExecutionException(
272                 "The service unit "
273                         + project.getArtifactId()
274                         + " does not have a dependency which is packaged as a jbi-component or a project property 'componentName'");
275     }
276
277 }
278
Popular Tags