| /* |
| * 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.felix.scrplugin.tags; |
| |
| import java.io.*; |
| import java.net.URL; |
| import java.net.URLClassLoader; |
| import java.util.*; |
| import java.util.jar.*; |
| |
| import org.apache.felix.scrplugin.Constants; |
| import org.apache.felix.scrplugin.om.Component; |
| import org.apache.felix.scrplugin.om.Components; |
| import org.apache.felix.scrplugin.tags.annotation.AnnotationJavaClassDescription; |
| import org.apache.felix.scrplugin.tags.annotation.AnnotationTagProviderManager; |
| import org.apache.felix.scrplugin.tags.cl.ClassLoaderJavaClassDescription; |
| import org.apache.felix.scrplugin.tags.qdox.QDoxJavaClassDescription; |
| import org.apache.felix.scrplugin.xml.ComponentDescriptorIO; |
| import org.apache.maven.artifact.Artifact; |
| import org.apache.maven.artifact.ArtifactUtils; |
| import org.apache.maven.plugin.MojoExecutionException; |
| import org.apache.maven.plugin.MojoFailureException; |
| import org.apache.maven.plugin.logging.Log; |
| import org.apache.maven.project.MavenProject; |
| import org.codehaus.plexus.util.*; |
| |
| import com.thoughtworks.qdox.JavaDocBuilder; |
| import com.thoughtworks.qdox.model.JavaClass; |
| import com.thoughtworks.qdox.model.JavaSource; |
| |
| /** |
| * <code>JavaClassDescriptorManager.java</code>... |
| * |
| */ |
| public class JavaClassDescriptorManager { |
| |
| protected static final String SERVICE_COMPONENT = "Service-Component"; |
| |
| /** The sources read by qdox. */ |
| protected final JavaSource[] sources; |
| |
| /** The maven log. */ |
| protected final Log log; |
| |
| /** The classloader used to compile the classes. */ |
| protected final ClassLoader classloader; |
| |
| /** A cache containing the java class descriptions hashed by classname. */ |
| protected final Map<String, JavaClassDescription> javaClassDescriptions = new HashMap<String, JavaClassDescription>(); |
| |
| /** The component definitions from other bundles hashed by classname. */ |
| protected final Map<String, Component> componentDescriptions = new HashMap<String, Component>(); |
| |
| /** The maven project. */ |
| protected final MavenProject project; |
| |
| /** |
| * Supports mapping of built-in and custom java anntoations to {@link JavaTag} implementations. |
| */ |
| protected final AnnotationTagProviderManager annotationTagProviderManager; |
| |
| /** Parse Javadocs? */ |
| protected final boolean parseJavadocs; |
| |
| /** Process Annotations? */ |
| protected final boolean processAnnotations; |
| |
| /** |
| * Construct a new manager. |
| * @param log |
| * @param project |
| * @param annotationTagProviders List of annotation tag providers |
| * @param excludeString The exclude information for sources |
| * @param parseJavadocs Should the javadocs be parsed? |
| * @param processAnnotations Should the annotations be processed? |
| * @throws MojoFailureException |
| * @throws MojoExecutionException |
| */ |
| public JavaClassDescriptorManager(final Log log, |
| final MavenProject project, |
| final String[] annotationTagProviders, |
| final String excludeString, |
| final boolean parseJavadocs, |
| final boolean processAnnotations) |
| throws MojoFailureException, MojoExecutionException { |
| this.processAnnotations = processAnnotations; |
| this.parseJavadocs = parseJavadocs; |
| this.log = log; |
| this.project = project; |
| this.annotationTagProviderManager = new AnnotationTagProviderManager(annotationTagProviders); |
| this.classloader = this.getCompileClassLoader(); |
| ClassUtil.classLoader = this.classloader; |
| |
| // get all the class sources through qdox |
| this.log.debug("Setting up QDox"); |
| JavaDocBuilder builder = new JavaDocBuilder(); |
| builder.getClassLibrary().addClassLoader(this.classloader); |
| @SuppressWarnings("unchecked") |
| final Iterator<String> i = project.getCompileSourceRoots().iterator(); |
| // FELIX-509: check for excludes |
| if ( excludeString != null ) { |
| final String[] excludes = StringUtils.split(excludeString, ","); |
| final String[] includes = new String[] {"**/*.java"}; |
| |
| while ( i.hasNext() ) { |
| final String tree = i.next(); |
| this.log.debug("Scanning source tree " + tree); |
| final File directory = new File(tree); |
| final DirectoryScanner scanner = new DirectoryScanner(); |
| scanner.setBasedir( directory ); |
| |
| if ( excludes != null && excludes.length > 0 ) { |
| scanner.setExcludes( excludes ); |
| } |
| scanner.addDefaultExcludes(); |
| scanner.setIncludes( includes ); |
| |
| scanner.scan(); |
| |
| final String[] files = scanner.getIncludedFiles(); |
| if ( files != null ) { |
| for(int m=0; m<files.length; m++) { |
| this.log.debug("Adding source file " + files[m]); |
| try { |
| builder.addSource(new File(directory, files[m])); |
| } catch (FileNotFoundException e) { |
| throw new MojoExecutionException("Unable to scan directory.", e); |
| } catch (IOException e) { |
| throw new MojoExecutionException("Unable to scan directory.", e); |
| } |
| } |
| } |
| } |
| } else { |
| while ( i.hasNext() ) { |
| final String tree = i.next(); |
| this.log.debug("Adding source tree " + tree); |
| final File directory = new File(tree); |
| builder.addSourceTree(directory); |
| } |
| } |
| this.sources = builder.getSources(); |
| |
| // and now scan artifacts |
| final List<Component> components = new ArrayList<Component>(); |
| @SuppressWarnings("unchecked") |
| final Map<String, Artifact> resolved = project.getArtifactMap(); |
| @SuppressWarnings("unchecked") |
| final Set<Artifact> artifacts = project.getDependencyArtifacts(); |
| final Iterator<Artifact> it = artifacts.iterator(); |
| while ( it.hasNext() ) { |
| final Artifact declared = it.next(); |
| this.log.debug("Checking artifact " + declared); |
| if ( this.isJavaArtifact(declared)) { |
| if (Artifact.SCOPE_COMPILE.equals(declared.getScope()) |
| || Artifact.SCOPE_RUNTIME.equals(declared.getScope()) |
| || Artifact.SCOPE_PROVIDED.equals(declared.getScope())) { |
| this.log.debug("Resolving artifact " + declared); |
| final Artifact artifact = resolved.get(ArtifactUtils.versionlessKey(declared)); |
| if (artifact != null) { |
| this.log.debug("Trying to get manifest from artifact " + artifact); |
| try { |
| final Manifest manifest = this.getManifest(artifact); |
| if ( manifest != null ) { |
| // read Service-Component entry |
| if ( manifest.getMainAttributes().getValue(JavaClassDescriptorManager.SERVICE_COMPONENT) != null ) { |
| final String serviceComponent = manifest.getMainAttributes().getValue(JavaClassDescriptorManager.SERVICE_COMPONENT); |
| this.log.debug("Found Service-Component: " + serviceComponent + " in artifact " + artifact); |
| final StringTokenizer st = new StringTokenizer(serviceComponent, ","); |
| while ( st.hasMoreTokens() ) { |
| final String entry = st.nextToken().trim(); |
| if ( entry.length() > 0 ) { |
| final Components c = this.readServiceComponentDescriptor(artifact, entry); |
| if ( c != null ) { |
| components.addAll(c.getComponents()); |
| } |
| } |
| } |
| } else { |
| this.log.debug("Artifact has no service component entry in manifest " + artifact); |
| } |
| } else { |
| this.log.debug("Unable to get manifest from artifact " + artifact); |
| } |
| } catch (IOException ioe) { |
| throw new MojoExecutionException("Unable to get manifest from artifact " + artifact, ioe); |
| } |
| this.log.debug("Trying to get scrinfo from artifact " + artifact); |
| // now read the scr private file - components stored there overwrite components already |
| // read from the service component section. |
| try { |
| final File scrInfoFile = this.getFile(artifact, Constants.ABSTRACT_DESCRIPTOR_ARCHIV_PATH); |
| if ( scrInfoFile != null ) { |
| components.addAll(this.parseServiceComponentDescriptor(artifact, scrInfoFile).getComponents()); |
| } else { |
| this.log.debug("Artifact has no scrinfo file (it's optional): " + artifact); |
| } |
| } catch (IOException ioe) { |
| throw new MojoExecutionException("Unable to get scrinfo from artifact " + artifact, ioe); |
| } |
| } else { |
| this.log.debug("Unable to resolve artifact " + declared); |
| } |
| } else { |
| this.log.debug("Artifact " + declared + " has not scope compile or runtime, but " + declared.getScope()); |
| } |
| } else { |
| this.log.debug("Artifact " + declared + " is not a java artifact, type is " + declared.getType()); |
| } |
| } |
| // now create map with component descriptions |
| for(final Component component : components) { |
| this.componentDescriptions.put(component.getImplementation().getClassame(), component); |
| } |
| } |
| |
| /** |
| * Check if the artifact is a java artifact (jar or bundle) |
| */ |
| private boolean isJavaArtifact(Artifact artifact) { |
| if ( "jar".equals(artifact.getType()) ) { |
| return true; |
| } |
| if ( "bundle".equals(artifact.getType()) ) { |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Return the log. |
| */ |
| public Log getLog() { |
| return this.log; |
| } |
| |
| /** |
| * Return the class laoder. |
| */ |
| public ClassLoader getClassLoader() { |
| return this.classloader; |
| } |
| |
| /** |
| * Return the project. |
| */ |
| public MavenProject getProject() { |
| return this.project; |
| } |
| |
| /** |
| * @return Annotation tag provider manager |
| */ |
| public AnnotationTagProviderManager getAnnotationTagProviderManager() { |
| return this.annotationTagProviderManager; |
| } |
| |
| /** |
| * Read the service component description. |
| * @param artifact |
| * @param entry |
| * @throws IOException |
| * @throws MojoExecutionException |
| */ |
| protected Components readServiceComponentDescriptor(Artifact artifact, String entry) { |
| this.log.debug("Reading " + entry + " from " + artifact); |
| try { |
| final File xml = this.getFile(artifact, entry); |
| if ( xml == null ) { |
| throw new MojoExecutionException("Artifact " + artifact + " does not contain declared service component descriptor " + entry); |
| } |
| return this.parseServiceComponentDescriptor(artifact, xml); |
| } catch (IOException mee) { |
| this.log.warn("Unable to read SCR descriptor file from artifact " + artifact + " at " + entry); |
| this.log.debug("Exception occurred during reading: " + mee.getMessage(), mee); |
| } catch (MojoExecutionException mee) { |
| this.log.warn("Unable to read SCR descriptor file from artifact " + artifact + " at " + entry); |
| this.log.debug("Exception occurred during reading: " + mee.getMessage(), mee); |
| } |
| return null; |
| } |
| |
| protected Components parseServiceComponentDescriptor(Artifact artifact, File file) |
| throws MojoExecutionException { |
| this.log.debug("Parsing " + file); |
| final Components list = ComponentDescriptorIO.read(file); |
| return list; |
| } |
| |
| /** |
| * Get the url for the target directory |
| */ |
| protected URL getOutputDirectory() |
| throws MojoFailureException { |
| final String targetDirectory = this.getProject().getBuild().getOutputDirectory(); |
| try { |
| return new File(targetDirectory).toURI().toURL(); |
| } catch (IOException ioe) { |
| throw new MojoFailureException("Unable to add target directory to classloader."); |
| } |
| } |
| |
| /** |
| * Create a class loader containing all compile artifacts including |
| * the target/class directory of the current project |
| * @return The class loader |
| * @throws MojoFailureException |
| */ |
| protected ClassLoader getCompileClassLoader() |
| throws MojoFailureException { |
| @SuppressWarnings("unchecked") |
| List<Artifact> artifacts = this.getProject().getCompileArtifacts(); |
| URL[] path = new URL[artifacts.size() + 1]; |
| int i = 0; |
| for (Iterator<Artifact> ai=artifacts.iterator(); ai.hasNext(); ) { |
| Artifact a = ai.next(); |
| try { |
| path[i++] = a.getFile().toURI().toURL(); |
| } catch (IOException ioe) { |
| throw new MojoFailureException("Unable to get compile class loader."); |
| } |
| } |
| path[path.length - 1] = this.getOutputDirectory(); |
| |
| return new URLClassLoader(path, this.getClass().getClassLoader()); |
| } |
| |
| protected Manifest getManifest(Artifact artifact) throws IOException { |
| JarFile file = null; |
| try { |
| file = new JarFile(artifact.getFile()); |
| return file.getManifest(); |
| } finally { |
| if (file != null) { |
| try { |
| file.close(); |
| } catch (IOException ignore) { |
| } |
| } |
| } |
| } |
| |
| protected File getFile(Artifact artifact, String path) throws IOException { |
| final int pos = path.lastIndexOf('.'); |
| final String suffix = path.substring(pos + 1); |
| JarFile file = null; |
| File tmpFile = null; |
| try { |
| file = new JarFile(artifact.getFile()); |
| final JarEntry entry = file.getJarEntry(path); |
| if ( entry != null ) { |
| tmpFile = File.createTempFile("scrjcdm" + artifact.getArtifactId(), suffix); |
| tmpFile.deleteOnExit(); |
| final FileOutputStream fos = new FileOutputStream(tmpFile); |
| IOUtil.copy(file.getInputStream(entry), fos); |
| IOUtil.close(fos); |
| return tmpFile; |
| } |
| return null; |
| } finally { |
| if (file != null) { |
| try { |
| file.close(); |
| } catch (IOException ignore) { |
| } |
| } |
| } |
| } |
| |
| /** |
| * Return all source descriptions of this project. |
| * @return All contained java class descriptions. |
| */ |
| public JavaClassDescription[] getSourceDescriptions() throws MojoExecutionException { |
| final JavaClassDescription[] descs = new JavaClassDescription[this.sources.length]; |
| for(int i=0; i<this.sources.length; i++) { |
| final String className = this.sources[i].getClasses()[0].getFullyQualifiedName(); |
| descs[i] = this.getJavaClassDescription(className); |
| } |
| return descs; |
| } |
| |
| /** |
| * Get a java class description for the class. |
| * @param className |
| * @return The java class description. |
| * @throws MojoExecutionException |
| */ |
| public JavaClassDescription getJavaClassDescription(String className) |
| throws MojoExecutionException { |
| JavaClassDescription result = this.javaClassDescriptions.get(className); |
| if ( result == null ) { |
| this.log.debug("Searching description for: " + className); |
| int index = 0; |
| while ( result == null && index < this.sources.length) { |
| final JavaClass javaClass = this.sources[index].getClasses()[0]; |
| if ( javaClass.getFullyQualifiedName().equals(className) ) { |
| try { |
| // check for java annotation descriptions - fallback to QDox if none found |
| Class<?> clazz = this.classloader.loadClass(className); |
| if (this.processAnnotations && getAnnotationTagProviderManager().hasScrPluginAnnotation(javaClass)) { |
| this.log.debug("Found java annotation description for: " + className); |
| result = new AnnotationJavaClassDescription(clazz, this.sources[index], this); |
| } else if ( this.parseJavadocs ) { |
| this.log.debug("Found qdox description for: " + className); |
| result = new QDoxJavaClassDescription(clazz, this.sources[index], this); |
| } |
| } catch (ClassNotFoundException e) { |
| throw new MojoExecutionException("Unable to load class " + className); |
| } |
| } else { |
| index++; |
| } |
| } |
| if ( result == null ) { |
| try { |
| this.log.debug("Generating classloader description for: " + className); |
| result = new ClassLoaderJavaClassDescription(this.classloader.loadClass(className), this.componentDescriptions.get(className), this); |
| } catch (ClassNotFoundException e) { |
| throw new MojoExecutionException("Unable to load class " + className); |
| } |
| } |
| this.javaClassDescriptions.put(className, result); |
| } |
| return result; |
| } |
| } |
