| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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. |
| */ |
| package org.apache.pluto.maven; |
| |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.apache.maven.plugin.MojoExecutionException; |
| import org.apache.maven.plugin.logging.Log; |
| import org.apache.pluto.util.UtilityException; |
| import org.apache.pluto.util.assemble.Assembler; |
| import org.apache.pluto.util.assemble.AssemblerConfig; |
| import org.apache.pluto.util.assemble.AssemblerFactory; |
| |
| /** |
| * The AssembleMojo is responsible for assembling a web application for deployment |
| * into the Pluto portlet container. Assembly, in this context, is the process of |
| * updating a web application's WEB-INF/web.xml with Pluto specific parameters for |
| * deployment in Pluto. |
| * <p> |
| * This Mojo is able to operate on individual descriptors by specifying |
| * <code>portletXml</code>, <code>webXml</code>, and <code>webXmlDestination</code>. |
| * If your project uses standard Maven 2 directory layouts, the defaults will |
| * provide proper values. |
| * <p/> |
| * Example Maven 2 <code>pom.xml</code> usage: |
| * <pre> |
| * <project> |
| * ... |
| * <build> |
| * <plugins> |
| * <plugin> |
| * <groupId>org.apache.pluto</groupId> |
| * <artifactId>maven-pluto-plugin</artifactId> |
| * </plugin> |
| * </plugins> |
| * </build> |
| * ... |
| * </project> |
| * </pre> |
| * <p> |
| * This Mojo can also operate on entire WAR or EAR archive files by specifying |
| * a list of archive path names in <code>archives</code>. |
| * <p/> |
| * Example Maven 2 <code>pom.xml</code> usage: |
| * <pre> |
| * <project> |
| * ... |
| * <build> |
| * <plugins> |
| * <plugin> |
| * <groupId>org.apache.pluto</groupId> |
| * <artifactId>maven-pluto-plugin</artifactId> |
| * <executions> |
| * <execution> |
| * <phase>package</phase> |
| * <goals> |
| * <goal>assemble</goal> |
| * </goals> |
| * <configuration> |
| * <assemblyOutputDirectory>${project.build.directory}/assembled-wars</assemblyOutputDirectory> |
| * <archives> |
| * <assembleArchive> |
| * ${project.build.directory}/wartoassemble.war |
| * </assembleArchive> |
| * <assembleArchive> |
| * ${project.build.directory}/anotherwartoassemble.war |
| * </assembleArchive> |
| * </archives> |
| * </configuration> |
| * </execution> |
| * </executions> |
| * </plugin> |
| * </plugins> |
| * </build> |
| * ... |
| * </project> |
| * </pre> |
| * |
| * @since Jul 30, 2005 |
| * @see org.apache.pluto.util.assemble.Assembler |
| * |
| * @goal assemble |
| * @description prepares a web application as a portlet application |
| * @phase process-resources |
| */ |
| public class AssembleMojo extends AbstractPortletMojo { |
| |
| // Private Member Variables ------------------------------------------------ |
| |
| /** |
| * The portlet application descriptor (<code>WEB-INF/portlet.xml</code>). |
| * @parameter expression="${basedir}/src/main/webapp/WEB-INF/portlet.xml" |
| * @required |
| */ |
| private File portletXml; |
| |
| /** |
| * The original webapp descriptor (<code>WEB-INF/web.xml</code>). |
| * @parameter expression="${basedir}/src/main/webapp/WEB-INF/web.xml" |
| * @required |
| */ |
| private File webXml; |
| |
| /** |
| * The file to which the updated webapp descriptor is written. |
| * @parameter expression="${project.build.directory}/pluto-resources/web.xml" |
| */ |
| private File webXmlDestination; |
| |
| /** |
| * The name of the dispatch servlet class to use |
| * @parameter |
| */ |
| private String dispatchServletClass; |
| |
| /** |
| * A list of archive files to assemble. Only EAR and WAR file |
| * types are supported. |
| * <p/> |
| * Each value in the list is the absolute pathname to the |
| * archive being assembled. |
| * <p/> |
| * This parameter is mutually exclusive with portletXml, webXml, |
| * and webXmlDestination parameters. |
| * |
| * @parameter alias="warFiles" |
| */ |
| private List archives; |
| |
| /** |
| * @deprecated see archives parameter |
| * @parameter |
| */ |
| private List warFiles; |
| |
| /** |
| * Destination directory the assembled files are written out to. |
| * @parameter alias="warFilesDestination" expression="${project.build.directory}/pluto-assembled-wars" |
| */ |
| private File assemblyOutputDirectory; |
| |
| /** |
| * Destination directory the assembled files are written out to. |
| * @parameter |
| * @deprecated see assemblyOutputDirectory parameter |
| */ |
| private File warFilesDestination; |
| |
| // AbstractPlutoMojo Impl -------------------------------------------------- |
| |
| protected void doExecute() throws MojoExecutionException { |
| |
| // Log parameter values. |
| Log log = getLog(); |
| if (log.isInfoEnabled()) { |
| if (archives == null || archives.isEmpty()) { |
| log.info("Reading web.xml from :" + webXml.getAbsolutePath()); |
| log.info("Reading portlet.xml from: " + portletXml.getAbsolutePath()); |
| log.info("Writing web.xml to: " + webXmlDestination.getAbsolutePath()); |
| } |
| } |
| |
| try { |
| // Assemble portlet app by updating web.xml. |
| if (archives == null || archives.isEmpty()) { |
| AssemblerConfig config = createAssemblerConfig(); |
| Assembler assembler = AssemblerFactory.getFactory() |
| .createAssembler(config); |
| assembler.assemble(config); |
| } else { |
| for (Iterator i = archives.iterator(); i.hasNext();) { |
| File archive = new File(i.next().toString()); |
| if (log.isInfoEnabled()) { |
| log.info("Assembling archive file " + archive.getAbsolutePath() + |
| " to directory " + assemblyOutputDirectory.getAbsolutePath()); |
| } |
| AssemblerConfig config = createArchiveAssemblerConfig(archive, assemblyOutputDirectory); |
| Assembler assembler = AssemblerFactory.getFactory() |
| .createAssembler(config); |
| assembler.assemble(config); |
| } |
| } |
| } catch (UtilityException e) { |
| log.error("Assembly failed: " + e.getMessage(), e); |
| } |
| } |
| |
| protected void doValidate() throws MojoExecutionException { |
| Log log = getLog(); |
| |
| // Support for the old 'warFiles' mojo parameter. Apparently |
| // the alias for the 'archives' parameter doesn't work properly. |
| if (! (warFiles == null || warFiles.isEmpty()) ) { |
| log.warn( "'warFiles' parameter is deprecated. Use 'archives' parameter instead." ); |
| if ( archives == null ) { |
| archives = new ArrayList(); |
| } |
| archives.addAll( warFiles ); |
| } |
| |
| // Warn if the old 'warFilesDestination' mojo parameter is used |
| if ( warFilesDestination != null ) { |
| log.warn( "'warFilesDestination' parameter is deprecated. Use 'assemblyOutputDirectory' instead." ); |
| assemblyOutputDirectory = warFilesDestination; |
| } |
| |
| // If a list of war files are supplied: |
| // 1) webXml, portletXml, and webXmlDestination parameters are ignored |
| // 2) verify the files in the List exist. |
| // 3) verify the destination is a directory, or create it if it doesn't exist. |
| |
| // A list of files was supplied so we ignore other parameters. |
| if (archives != null && !archives.isEmpty()) { |
| if (webXml != null) { |
| log.debug("archives parameter and webXml parameter are mutually exclusive. Ignoring webXml parameter."); |
| } |
| if (portletXml != null) { |
| log.debug("archives parameter and portletXml parameter are mutually exclusive. Ignoring portletXml parameter."); |
| } |
| if (webXmlDestination != null) { |
| log.debug("archives parameter and webXmlDestination parameter are mutually exclusive. Ignoring webXmlDestination parameter."); |
| } |
| |
| // verify each file can be found |
| for (Iterator i = archives.iterator(); i.hasNext();) { |
| File f = new File(i.next().toString()); |
| if (!f.exists()) { |
| log.warn("File " + f.getAbsolutePath() + " does not exist."); |
| i.remove(); |
| continue; |
| } |
| if (!f.canRead()) { |
| log.warn("File " + f.getAbsolutePath() + " exists but cannot be read."); |
| i.remove(); |
| continue; |
| } |
| } |
| |
| // check to see if the warFiles list is now empty |
| if (archives.isEmpty()) { |
| throw new MojoExecutionException("No war files could be installed due errors."); |
| } |
| |
| // check to see if the dest dir exists or create it. |
| if (!assemblyOutputDirectory.exists()) { |
| if (log.isDebugEnabled()) { |
| log.debug("Creating destination directory for assembled war files: " + assemblyOutputDirectory.getAbsolutePath()); |
| } |
| try { |
| if(!assemblyOutputDirectory.mkdirs()) { |
| throw new MojoExecutionException("Unable to create destination directory for assembled war files: " + |
| assemblyOutputDirectory.getAbsolutePath()); |
| } |
| } catch (SecurityException e) { |
| throw new MojoExecutionException("Unable to create destination directory for assembled war files: " + e.getMessage(), e); |
| } |
| } else { |
| if (!assemblyOutputDirectory.isDirectory()) { |
| throw new MojoExecutionException("Specified destination for assembled war files " + |
| assemblyOutputDirectory.getAbsolutePath() + " is not a directory!"); |
| } |
| if (!assemblyOutputDirectory.canRead()||!assemblyOutputDirectory.canWrite()) { |
| throw new MojoExecutionException("Unable to read or write to destination directory for assembed war files. " + |
| "Check permissions on the directory " + assemblyOutputDirectory.getAbsolutePath()); |
| } |
| } |
| |
| // A list of archive files was not provided, so use the other parameters instead. |
| |
| } else { |
| if (webXml == null || !webXml.exists()) { |
| throw new MojoExecutionException("Web application descriptor must be a valid web.xml"); |
| } |
| if (portletXml == null || !portletXml.exists()) { |
| throw new MojoExecutionException("Portlet descriptor must be a valid portlet.xml"); |
| } |
| } |
| } |
| |
| // Private Methods --------------------------------------------------------- |
| |
| private AssemblerConfig createAssemblerConfig() { |
| AssemblerConfig config = new AssemblerConfig(); |
| config.setPortletDescriptor(portletXml); |
| config.setWebappDescriptor(webXml); |
| config.setDestination(webXmlDestination); |
| config.setDispatchServletClass(dispatchServletClass); |
| return config; |
| } |
| |
| private AssemblerConfig createArchiveAssemblerConfig(File archiveToAssemble, File destinationDirectory) { |
| AssemblerConfig config = new AssemblerConfig(); |
| config.setDispatchServletClass(dispatchServletClass); |
| config.setSource(archiveToAssemble); |
| config.setDestination(destinationDirectory); |
| return config; |
| } |
| |
| } |