Java tutorial
/******************************************************************************* * Copyright (c) 2006-2010 eBay Inc. All Rights Reserved. * Licensed 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 *******************************************************************************/ package org.ebayopensource.turmeric.plugins.maven; import java.io.File; import java.io.FileFilter; import java.io.IOException; import java.io.InputStream; import java.net.URL; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Properties; import java.util.logging.Handler; import java.util.logging.Logger; import java.util.regex.Pattern; import org.apache.commons.io.FilenameUtils; import org.apache.maven.model.Resource; import org.apache.maven.plugin.AbstractMojo; import org.apache.maven.plugin.MojoExecutionException; import org.apache.maven.plugin.MojoFailureException; import org.apache.maven.project.MavenProject; import org.codehaus.plexus.interpolation.EnvarBasedValueSource; import org.codehaus.plexus.interpolation.InterpolationException; import org.codehaus.plexus.interpolation.Interpolator; import org.codehaus.plexus.interpolation.PrefixedObjectValueSource; import org.codehaus.plexus.interpolation.PropertiesBasedValueSource; import org.codehaus.plexus.interpolation.RegexBasedInterpolator; import org.codehaus.plexus.resource.ResourceManager; import org.codehaus.plexus.resource.loader.FileResourceLoader; import org.codehaus.plexus.resource.loader.ThreadContextClasspathResourceLoader; import org.codehaus.plexus.resource.loader.URLResourceLoader; import org.codehaus.plexus.util.IOUtil; import org.codehaus.plexus.util.StringUtils; import org.ebayopensource.turmeric.plugins.maven.resources.ResourceLocator.Location; import org.ebayopensource.turmeric.plugins.maven.utils.AddMatchingFilesFilter; import org.ebayopensource.turmeric.plugins.maven.utils.GenTimestamp; import org.ebayopensource.turmeric.plugins.maven.utils.LogDelegateHandler; import org.ebayopensource.turmeric.tools.codegen.NonInteractiveCodeGen; import org.jdom.Document; import org.jdom.Element; import org.jdom.JDOMException; import org.jdom.input.SAXBuilder; /** * Base level mojo for the most common turmeric parameters, and methods. */ public abstract class AbstractTurmericMojo extends AbstractMojo { private static final String GROUPID_SELF = "org.ebayopensource.turmeric.maven"; private static final String ARTIFACTID_SELF = "turmeric-maven-plugin"; /** * The default maven project object * * @parameter expression="${project}" * @required * @readonly */ protected MavenProject project; /** * * @parameter expression="${turmeric.verbose}" default-value="true" * @required */ protected boolean verbose; /** * Plexus component used to lookup resources from a variety of search locations (including Thread context * classloader, a file resource from the project base, a file resource from the project resources directories, a * fully qualified file path, or even a url) * * @component role="org.codehaus.plexus.resource.ResourceManager" role-hint="default" * @required * @readonly */ private ResourceManager locator; /** * Timestamp file used for tracking last generation and preventing a loop of generation seen in m2eclipse. * * @parameter expression="${project.build.directory}/turmeric-maven-plugin-gen-timestamp" * @required */ private File timestampFile; private GenTimestamp timestamps; private boolean locatorAlreadyConfigured = false; protected final void ensureDirectoryExists(String id, File dir) throws MojoExecutionException { if (!dir.exists()) { if (!dir.mkdirs()) { throw new MojoExecutionException("Unable to create " + id + ": " + dir); } } } /** * Wraps the mojo execute with some behavioral lifecycle. */ @Override public final void execute() throws MojoExecutionException, MojoFailureException { getLog().debug("[execute]"); getLog().info("Using turmeric-maven-plugin version " + getTurmericMavenPluginVersion()); if (executeSkip()) { getLog().warn("Skipping execution"); return; } if (verbose) { logDependencyDetails("Turmeric Maven Plugin", AbstractTurmericMojo.class, GROUPID_SELF, ARTIFACTID_SELF); logDependencyDetails("Codegen Tools", NonInteractiveCodeGen.class, "org.ebayopensource.turmeric.runtime", "soa-client"); getLog().info("Verbose Mode: enabling java.util.logging"); // Initialize java.util.logging (which is present in CodeGen classes) Logger root = Logger.getLogger(""); // Remove old delegates for (Handler handler : root.getHandlers()) { getLog().info("Removing existing logging handler: " + handler.getClass().getName()); root.removeHandler(handler); } // Add our delegate root.addHandler(new LogDelegateHandler(getLog())); } getLog().debug("[onValidateParameters]"); onValidateParameters(); // Test for need to generate getLog().debug("[needsGeneration]"); if (needsGeneration() == false) { getLog().warn("No need to generate. skipping turmeric plugin execution."); return; } try { getLog().debug("[onRunSetup]"); onRunSetup(); // Attach directories to project even if skipping servicegen. // This is to be a good maven and m2eclipse citizen. getLog().debug("[onAttachGeneratedDirectories]"); onAttachGeneratedDirectories(); getLog().debug("[onRun]"); onRun(); } finally { getLog().debug("[onRunTearDown]"); onRunTearDown(); } } /** * Look into the ${project.basedir}/.project file and see if the turmeric eclipse plugin's nature for codegen is * defined. * * @return */ public boolean isTurmericEclipsePluginEnabled() { File projectFile = new File(project.getBasedir(), ".project"); if (!projectFile.exists()) { // No .project file, not using turmeric eclipse plugin return false; } try { Document doc = parseXml(projectFile); Pattern legacyNaturePattern = Pattern .compile("^org\\.ebay\\.soaframework\\.eclipse\\.SOA[A-Za-z0-9]*ProjectNature$"); Pattern naturePattern = Pattern .compile("^org\\.ebayopensource\\.turmeric\\.eclipse\\.build\\.SOA[A-Za-z0-9]*ProjectNature$"); Pattern typeLibNaturePattern = Pattern.compile( "^org\\.ebayopensource\\.turmeric\\.eclipse\\.typelibrary\\.Type[A-Za-z0-9]*ProjectNature$"); Pattern errorLibNaturePattern = Pattern.compile( "^org\\.ebayopensource\\.turmeric\\.eclipse\\.errorlibrary\\.properties\\.TurmericError[A-Za-z0-9]*ProjectNature$"); Element root = doc.getRootElement(); if (!"projectDescription".equals(root.getName())) { getLog().error("Not an eclipse .project file" + " (format mismatch): " + projectFile); return false; } @SuppressWarnings("unchecked") List<Element> naturesList = root.getChildren("natures"); for (Element natureRoot : naturesList) { @SuppressWarnings("unchecked") List<Element> natures = natureRoot.getChildren("nature"); for (Element nature : natures) { String natureSpec = nature.getTextTrim(); if (naturePattern.matcher(natureSpec).matches() || legacyNaturePattern.matcher(natureSpec).matches() || typeLibNaturePattern.matcher(natureSpec).matches() || errorLibNaturePattern.matcher(natureSpec).matches()) { return true; } } } } catch (MojoExecutionException e) { getLog().error("Unable to parse Eclipse .project file: " + projectFile, e); } return false; } /** * Obtains the as-built version of the turmeric maven plugin for reporting to the user. */ private String getTurmericMavenPluginVersion() { String pompath = String.format("META-INF/maven/%s/%s/pom.properties", GROUPID_SELF, ARTIFACTID_SELF); URL url = this.getClass().getClassLoader().getResource(pompath); if (url == null) { return "(unknown/dev)"; } Properties props = new Properties(); InputStream stream = null; try { stream = url.openStream(); props.load(stream); String version = props.getProperty("version"); if (StringUtils.isBlank(version)) { return "(unknown)"; } return version; } catch (IOException e) { getLog().debug("Unable to read version from: " + pompath, e); return "(unknown/io)"; } finally { IOUtil.close(stream); } } public void logDependencyDetails(String header, Class<?> clazz, String groupId, String artifactId) { StringBuilder msg = new StringBuilder(); msg.append(header); msg.append("\n Version: ").append(getClassVersion(clazz, groupId, artifactId)); msg.append("\n Location: ").append(getJarLocationOfClass(clazz)); getLog().info(msg.toString()); } public void logClassLocation(Class<?> clazz) { getLog().info("Location of class: " + clazz.getName()); getLog().info(" is: " + getJarLocationOfClass(clazz)); } public String getClassVersion(Class<?> clazz, String groupId, String artifactId) { try { String ver; ver = getPackageVersion(clazz); if (ver != null) { return ver; } ver = getMavenVersion(groupId, artifactId); if (ver != null) { return ver; } } catch (Exception ignore) { /* ignore */ } return "<unknown>"; } private String getMavenVersion(String groupId, String artifactId) { try { String resource = String.format("META-INF/maven/%s/%s/pom.properties", groupId, artifactId); URL url = this.getClass().getClassLoader().getResource(resource); if (url == null) { return null; } InputStream in = null; try { in = url.openStream(); Properties props = new Properties(); props.load(in); return props.getProperty("version"); } finally { IOUtil.close(in); } } catch (Exception ignore) { /* ignore */ } return null; } private static String getPackageVersion(Class<?> clazz) { Package p = clazz.getPackage(); if (p == null) { return null; } String ver = p.getImplementationVersion(); if (ver == null) { return null; } return ver; } public static String getJarLocationOfClass(Class<?> clazz) { try { String classpath = clazz.getName().replace('.', '/') + ".class"; URL resource = clazz.getClassLoader().getResource(classpath); if (resource != null) { String uri = resource.toExternalForm(); int idx = uri.lastIndexOf("!"); if (idx > 0) { uri = uri.substring(0, idx); return uri; } else if (uri.endsWith(classpath)) { return uri.substring(0, uri.length() - classpath.length()); } else { return uri; } } } catch (Exception ignore) { /* ignore */ } return "<unknown>"; } /** * Attempt to determine if we are running within the Eclipse environment. */ public boolean isMojoRunningInEclipse() { try { getLog().debug("Eclipse Check: is org.eclipse.core.launcher.Main in classpath?"); // Simple check: is launcher main in classpath Class<?> c = Class.forName("org.eclipse.core.launcher.Main"); if (c != null) { return true; } } catch (ClassNotFoundException e) { /* * Launcher not found in classpath. Perform other tests in an attempt to verify. */ } String FS = File.separator; // Are we using a plugin embedded maven (1/2) // Test the "java.class.path" property String jClassPath = System.getProperty("java.class.path"); if (StringUtils.isNotBlank(jClassPath)) { String expected = FS + "plugins" + FS + "org.maven.ide.eclipse"; getLog().debug( "Eclipse Check: \"java.class.path\" = \"" + jClassPath + "\".contains(\"" + expected + "\")"); if (jClassPath.contains(expected)) { // We are using a plugin embedded maven return true; } } // Are we using a plugin embedded maven (2/2) // Test the "classworlds.conf" property String cworldConf = System.getProperty("classworlds.conf"); if (StringUtils.isNotBlank(cworldConf)) { String expected = FS + ".metadata" + FS + ".plugins" + FS + "org.maven.ide.eclipse"; getLog().debug( "Eclipse Check: \"classworlds.conf\" = \"" + cworldConf + "\".contains(\"" + expected + "\")"); if (cworldConf.contains(expected)) { // We are using a plugin embedded maven. return true; } } getLog().debug("Eclipse Check: Not running in Eclipse."); return false; } /** * Convenience method for using {@link #expandParameter(String)} with File objects. * * @param rawfile * the raw file object * @return null if rawfile is null, or the expanded File object. * @throws MojoExecutionException */ public File expandFile(File rawfile) throws MojoExecutionException { if (rawfile == null) { return null; } String rawpath = rawfile.getPath(); return new File(expandParameter(rawpath)); } /** * Take a raw parameter value, and expand any found properties within it. * * @param parameter * @return the expanded parameter * @throws MojoExecutionException * if unable to interpolate */ public String expandParameter(String rawparameter) throws MojoExecutionException { if (StringUtils.isBlank(rawparameter)) { return rawparameter; } try { Interpolator interpolator = new RegexBasedInterpolator(); interpolator.addValueSource(new PrefixedObjectValueSource("project", project)); interpolator.addValueSource(new PrefixedObjectValueSource("mojo", this)); interpolator.addValueSource(new PropertiesBasedValueSource(System.getProperties())); interpolator.addValueSource(new EnvarBasedValueSource()); String result = interpolator.interpolate(rawparameter); if (getLog().isDebugEnabled()) { getLog().debug("Expand Parameter: " + "\n Raw: " + rawparameter + "\n Expanded: " + result); } return result; } catch (IOException e) { throw new MojoExecutionException("Unable to use Environment for Parameter Interpolation", e); } catch (InterpolationException e) { throw new MojoExecutionException("Unable to use interpolatate: " + rawparameter, e); } } /** * Look through all project.resources trees and find the pathref specified. * <p> * Since this mojo executes in the 'generate-sources' phase, we can't rely on the resources being (yet) present in * the output directories, as that occurs later in the maven lifecycle in the 'process-resources' phase. See <a * href="http://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html#Lifecycle_Reference" >Maven * Lifecycle</a> for details of phase order. * * @param pathref * the pathref within the resource directory to look for * @return the File path pointing to the resources directory content, or null if not found. */ protected final File findResourceFile(String pathref) { if (StringUtils.isBlank(pathref)) { getLog().warn("Unable to lookup resource for null pathref: " + pathref); return null; } List<?> resources = project.getBuild().getResources(); getLog().debug("Looking for resource in [" + resources.size() + "] directories: " + pathref); Iterator<?> iter = resources.iterator(); while (iter.hasNext()) { Resource resource = (Resource) iter.next(); String resDir = resource.getDirectory(); if (StringUtils.isBlank(resDir)) { getLog().warn("Blank resources directory: " + resource); continue; } File dir = new File(resDir); getLog().debug("Testing for resource in dir: " + dir); File possiblePath = new File(dir, pathref); if (possiblePath.exists()) { getLog().debug("Found resource: " + possiblePath); return possiblePath; } } return null; } /** * Get a configured ResourceManager for location lookups. * <p> * Note: be sure you set the {@link ResourceManager#setOutputDirectory(File)}! * * @return the resource locator to use. */ protected ResourceManager getResourceLocator() { if (locatorAlreadyConfigured) { return locator; } locatorAlreadyConfigured = true; locator.addSearchPath(ThreadContextClasspathResourceLoader.ID, ""); locator.addSearchPath(FileResourceLoader.ID, project.getBasedir().getAbsolutePath()); List<?> resources = project.getBuild().getResources(); Iterator<?> iter = resources.iterator(); while (iter.hasNext()) { Resource resource = (Resource) iter.next(); locator.addSearchPath(FileResourceLoader.ID, resource.getDirectory()); } locator.addSearchPath(URLResourceLoader.ID, ""); return locator; } public MavenProject getProject() { return project; } public boolean isVerbose() { return verbose; } /** * Internal check to see if execution is needed. * <p> * This differs from {@link #needsGeneration()} in so far that the variables on the mojo are not validated or * expanded at this point in the mojo lifecycle. * <p> * This is really only useful in mitigating the conflict that appears when the same functionality exists between a * specific Mojo goal and an Eclipse Plugin. * * @return true to indicate that execution can be skipped. * @throws MojoExecutionException * when wrapping other exceptions. Will cause build to go into error, resulting in a "BUILD ERROR" * message. The build will stop. * @throws MojoFailureException * to throw new exceptions. Will cause build to go into error, resulting in a "BUILD FAILURE" message. * The build will stop. */ public boolean executeSkip() throws MojoExecutionException, MojoFailureException { // Default is to not skip execution. return false; } /** * Internal check to see if generation is needed. * * @return true to indicate that generation is required, false to skip generation * @throws MojoExecutionException * when wrapping other exceptions. Will cause build to go into error, resulting in a "BUILD ERROR" * message. The build will stop. * @throws MojoFailureException * to throw new exceptions. Will cause build to go into error, resulting in a "BUILD FAILURE" message. * The build will stop. */ public abstract boolean needsGeneration() throws MojoExecutionException, MojoFailureException; /** * Attach any of the generated directories. */ protected abstract void onAttachGeneratedDirectories(); /** * The name of the goal for the mojo. */ protected abstract String getGoalName(); /** * Event to perform mojo operations on. * * @throws MojoExecutionException * when wrapping other exceptions. Will cause build to go into error, resulting in a "BUILD ERROR" * message. The build will stop. * @throws MojoFailureException * to throw new exceptions. Will cause build to go into error, resulting in a "BUILD FAILURE" message. * The build will stop. */ public void onRun() throws MojoExecutionException, MojoFailureException { /* perform actual mojo steps */ } /** * Event to perform setup for a run of the mojo. * * @throws MojoExecutionException * when wrapping other exceptions. Will cause build to go into error, resulting in a "BUILD ERROR" * message. The build will stop. * @throws MojoFailureException * to throw new exceptions. Will cause build to go into error, resulting in a "BUILD FAILURE" message. * The build will stop. */ protected void onRunSetup() throws MojoExecutionException, MojoFailureException { /* setup directory output, copy files around, download files, etc ... */ } /** * Event to perform teardown for a run of the mojo. * * @throws MojoExecutionException * when wrapping other exceptions. Will cause build to go into error, resulting in a "BUILD ERROR" * message. The build will stop. * @throws MojoFailureException * to throw new exceptions. Will cause build to go into error, resulting in a "BUILD FAILURE" message. * The build will stop. */ protected void onRunTearDown() throws MojoExecutionException, MojoFailureException { /* cleanup temporary files, etc ... */ ensureDirectoryExists("Timestamp Home Dir", timestampFile.getParentFile()); timestamps.write(); } /** * Event to perform parameter validation on. * * @throws MojoExecutionException * when wrapping other exceptions. Will cause build to go into error, resulting in a "BUILD ERROR" * message. The build will stop. * @throws MojoFailureException * to throw new exceptions. Will cause build to go into error, resulting in a "BUILD FAILURE" message. * The build will stop. */ protected void onValidateParameters() throws MojoExecutionException, MojoFailureException { if (project == null) { throw new MojoFailureException("No project present!"); } timestampFile = expandFile(timestampFile); timestamps = new GenTimestamp(getLog(), timestampFile); } /** * Tests the provided paths against the last timestamp persisted to know if any of the paths have changed. * * @param paths * the paths to verify against. * @return true if a timestamp is newer than the persisted one. * @see GenTimestamp#isNewerThan(String, File...) */ protected boolean isNewerThanLastTimestamp(File... paths) { return timestamps.isNewerThan(getGoalName(), paths); } /** * Tests the provided live locations against the last timestamp persisted to know if any of the locations have * changed. * * @param locations * the locations to verify against. (non-live locations are ignored) * @return true if a timestamp is newer than the persisted one. * @see GenTimestamp#isNewerThan(String, File...) */ protected boolean isNewerThanLastTimestamp(Location... locations) { List<File> paths = new ArrayList<File>(); for (Location location : locations) { if (location == null) { continue; // skip null entries } if (location.isLiveFile()) { paths.add(location.getFile()); } } if (paths.isEmpty()) { // No paths, no change. return false; } return timestamps.isNewerThan(getGoalName(), paths.toArray(new File[0])); } /** * Get the project's pom.xml file. * * @return the project's pom.xml file (could be named something other than pom.xml) */ protected File getProjectPomFile() { return project.getFile(); } /** * Ensure that the path has appropriate separators for the system in use. * * @param path * the raw input path. * @return the corrected system separators */ protected String toOS(String path) { return FilenameUtils.separatorsToSystem(path); } /** * Validates that a resources exists in the project's resources. * * @param msg * the type of resource * @param pathref * the path reference to the resource. * @throws MojoFailureException */ protected void validateResourceExists(String msg, String pathref) throws MojoFailureException { File path = findResourceFile(pathref); if ((path == null) || (path.exists() == false)) { throw new MojoFailureException("Missing Required resource (" + msg + "): " + pathref); } } protected Document parseXml(File xmlfile) throws MojoExecutionException { try { SAXBuilder builder = new SAXBuilder(false); return builder.build(xmlfile); } catch (JDOMException e) { throw new MojoExecutionException("Unable to parse: " + xmlfile, e); } catch (IOException e) { throw new MojoExecutionException("Unable to parse: " + xmlfile, e); } } /** * Search through the project resource directories, and attempt to find a set of {@link File}s that match the * provided regex pattern. * * @param regex * the regex pattern to look for * @return the list of Files found (may be empty) */ protected List<File> findProjectResourceFiles(String regex) { List<File> hits = new ArrayList<File>(); Pattern pattern = Pattern.compile(regex); File dir; @SuppressWarnings("unchecked") List<Resource> resources = project.getBuild().getResources(); for (Resource resource : resources) { dir = new File(resource.getDirectory()); recursiveAddMatchingFiles(dir, new AddMatchingFilesFilter(getLog(), dir, pattern, hits)); } return hits; } private void recursiveAddMatchingFiles(File dir, FileFilter filter) { for (File path : dir.listFiles()) { if (path.isFile()) { filter.accept(path); continue; } if (path.isDirectory()) { recursiveAddMatchingFiles(path, filter); } } } }