/*
* 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.sling.maven.bundlesupport;
import static org.objectweb.asm.ClassReader.*;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
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.apache.sling.adapter.annotations.Adaptable;
import org.apache.sling.adapter.annotations.Adaptables;
import org.apache.sling.commons.json.JSONArray;
import org.apache.sling.commons.json.JSONException;
import org.apache.sling.commons.json.JSONObject;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.StringUtils;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.AnnotationNode;
import org.objectweb.asm.tree.ClassNode;
import org.scannotation.AnnotationDB;
/**
* @goal generate-adapter-metadata
* @phase process-classes
* @threadSafe
* @description Build Adapter Metadata from Annotated Classes
* @requiresDependencyResolution compile
*/
public class GenerateAdapterMetadataMojo extends AbstractMojo {
private static final int JSON_INDENTATION = 4;
private static final String ADAPTABLE_DESC = "L" + Adaptable.class.getName().replace('.', '/') + ";";
private static final String ADAPTABLES_DESC = "L" + Adaptables.class.getName().replace('.', '/') + ";";
private static final String DEFAULT_CONDITION = "If the adaptable is a %s.";
private static String getSimpleName(final ClassNode clazz) {
final String internalName = clazz.name;
final int idx = internalName.lastIndexOf('/');
if (idx == -1) {
return internalName;
} else {
return internalName.substring(idx + 1);
}
}
/**
* @parameter expression="${project.build.outputDirectory}"
* @required
* @readonly
*/
private File buildOutputDirectory;
/**
* Name of the generated descriptor file.
*
* @parameter expression="${adapter.descriptor.name}"
* default-value="SLING-INF/adapters.json"
*/
private String fileName;
/**
* @parameter
* expression="${project.build.directory}/adapter-plugin-generated"
* @required
* @readonly
*/
private File outputDirectory;
/**
* The Maven project.
*
* @parameter expression="${project}"
* @required
* @readonly
*/
private MavenProject project;
public void execute() throws MojoExecutionException, MojoFailureException {
try {
final JSONObject descriptor = new JSONObject();
final AnnotationDB annotationDb = new AnnotationDB();
annotationDb.scanArchives(buildOutputDirectory.toURI().toURL());
final Set<String> annotatedClassNames = new HashSet<String>();
addAnnotatedClasses(annotationDb, annotatedClassNames, Adaptable.class);
addAnnotatedClasses(annotationDb, annotatedClassNames, Adaptables.class);
for (final String annotatedClassName : annotatedClassNames) {
getLog().info(String.format("found adaptable annotation on %s", annotatedClassName));
final String pathToClassFile = annotatedClassName.replace('.', '/') + ".class";
final File classFile = new File(buildOutputDirectory, pathToClassFile);
final FileInputStream input = new FileInputStream(classFile);
final ClassReader classReader;
try {
classReader = new ClassReader(input);
} finally {
input.close();
}
final ClassNode classNode = new ClassNode();
classReader.accept(classNode, SKIP_CODE | SKIP_DEBUG | SKIP_FRAMES);
@SuppressWarnings("unchecked")
final List<AnnotationNode> annotations = classNode.invisibleAnnotations;
for (final AnnotationNode annotation : annotations) {
if (ADAPTABLE_DESC.equals(annotation.desc)) {
parseAdaptableAnnotation(annotation, classNode, descriptor);
} else if (ADAPTABLES_DESC.equals(annotation.desc)) {
parseAdaptablesAnnotation(annotation, classNode, descriptor);
}
}
}
final File outputFile = new File(outputDirectory, fileName);
outputFile.getParentFile().mkdirs();
final FileWriter writer = new FileWriter(outputFile);
try {
IOUtil.copy(descriptor.toString(JSON_INDENTATION), writer);
} finally {
IOUtil.close(writer);
}
addResource();
} catch (IOException e) {
throw new MojoExecutionException("Unable to generate metadata", e);
} catch (JSONException e) {
throw new MojoExecutionException("Unable to generate metadata", e);
}
}
private void addAnnotatedClasses(final AnnotationDB annotationDb, final Set<String> annotatedClassNames, final Class<? extends Annotation> clazz) {
Set<String> classNames = annotationDb.getAnnotationIndex().get(clazz.getName());
if (classNames == null || classNames.isEmpty()) {
getLog().debug("No classes found with adaptable annotations.");
} else {
annotatedClassNames.addAll(classNames);
}
}
private void addResource() {
final String ourRsrcPath = this.outputDirectory.getAbsolutePath();
boolean found = false;
@SuppressWarnings("unchecked")
final Iterator<Resource> rsrcIterator = this.project.getResources().iterator();
while (!found && rsrcIterator.hasNext()) {
final Resource rsrc = rsrcIterator.next();
found = rsrc.getDirectory().equals(ourRsrcPath);
}
if (!found) {
final Resource resource = new Resource();
resource.setDirectory(this.outputDirectory.getAbsolutePath());
this.project.addResource(resource);
}
}
private void parseAdaptablesAnnotation(final AnnotationNode annotation, final ClassNode classNode,
final JSONObject descriptor) throws JSONException {
final Iterator<?> it = annotation.values.iterator();
while (it.hasNext()) {
Object name = it.next();
Object value = it.next();
if ("value".equals(name)) {
@SuppressWarnings("unchecked")
final List<AnnotationNode> annotations = (List<AnnotationNode>) value;
for (final AnnotationNode innerAnnotation : annotations) {
if (ADAPTABLE_DESC.equals(innerAnnotation.desc)) {
parseAdaptableAnnotation(innerAnnotation, classNode, descriptor);
}
}
}
}
}
@SuppressWarnings("unchecked")
private void parseAdaptableAnnotation(final AnnotationNode annotation, final ClassNode annotatedClass,
final JSONObject descriptor) throws JSONException {
String adaptableClassName = null;
List<AnnotationNode> adapters = null;
String servicePid = null;
final List<?> values = annotation.values;
final Iterator<?> it = values.iterator();
while (it.hasNext()) {
Object name = it.next();
Object value = it.next();
if ("adaptableClass".equals(name)) {
adaptableClassName = ((Type) value).getClassName();
} else if ("adapters".equals(name)) {
adapters = (List<AnnotationNode>) value;
}
}
if (adaptableClassName == null || adapters == null) {
throw new IllegalArgumentException(
"Adaptable annotation is malformed. Expecting a classname and a list of adapter annotation.");
}
JSONObject adaptableDescription;
if (descriptor.has(adaptableClassName)) {
adaptableDescription = descriptor.getJSONObject(adaptableClassName);
} else {
adaptableDescription = new JSONObject();
descriptor.put(adaptableClassName, adaptableDescription);
}
for (final AnnotationNode adapter : adapters) {
parseAdapterAnnotation(adapter, annotatedClass, adaptableDescription);
}
}
@SuppressWarnings("unchecked")
private void parseAdapterAnnotation(final AnnotationNode annotation, final ClassNode annotatedClass,
final JSONObject adaptableDescription) throws JSONException {
String condition = null;
List<Type> adapterClasses = null;
final List<?> values = annotation.values;
final Iterator<?> it = values.iterator();
while (it.hasNext()) {
final Object name = it.next();
final Object value = it.next();
if (StringUtils.isEmpty(condition)) {
condition = String.format(DEFAULT_CONDITION, getSimpleName(annotatedClass));
}
if ("condition".equals(name)) {
condition = (String) value;
} else if ("value".equals(name)) {
adapterClasses = (List<Type>) value;
}
}
if (adapterClasses == null) {
throw new IllegalArgumentException("Adapter annotation is malformed. Expecting a list of adapter classes");
}
for (final Type adapterClass : adapterClasses) {
adaptableDescription.accumulate(condition, adapterClass.getClassName());
}
}
}