package org.glassfish.jersey.server.wadl.internal.generators;
import java.io.CharArrayWriter;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.ws.rs.core.GenericType;
import javax.ws.rs.core.MediaType;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.JAXBIntrospector;
import javax.xml.bind.SchemaOutputResolver;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSeeAlso;
import javax.xml.namespace.QName;
import javax.xml.transform.Result;
import javax.xml.transform.stream.StreamResult;
import org.glassfish.jersey.server.model.Parameter;
import org.glassfish.jersey.server.wadl.WadlGenerator;
import org.glassfish.jersey.server.wadl.internal.ApplicationDescription;
import org.glassfish.jersey.server.wadl.internal.WadlGeneratorImpl;
import com.sun.research.ws.wadl.Application;
import com.sun.research.ws.wadl.Method;
import com.sun.research.ws.wadl.Param;
import com.sun.research.ws.wadl.Representation;
import com.sun.research.ws.wadl.Request;
import com.sun.research.ws.wadl.Resource;
import com.sun.research.ws.wadl.Resources;
import com.sun.research.ws.wadl.Response;
public class WadlGeneratorJAXBGrammarGenerator implements WadlGenerator {
private static interface NameCallbackSetter {
public void setName(QName name);
}
private class TypeCallbackPair {
public TypeCallbackPair(final GenericType<?> genericType, final NameCallbackSetter nameCallbackSetter) {
this.genericType = genericType;
this.nameCallbackSetter = nameCallbackSetter;
}
GenericType<?> genericType;
NameCallbackSetter nameCallbackSetter;
}
private static final Logger LOGGER = Logger.getLogger(WadlGeneratorJAXBGrammarGenerator.class.getName());
private static final java.util.Set<Class> SPECIAL_GENERIC_TYPES =
new HashSet<Class>() {{
add(List.class);
}};
private WadlGenerator wadlGeneratorDelegate;
private Set<Class> seeAlsoClasses;
private List<TypeCallbackPair> nameCallbacks;
public WadlGeneratorJAXBGrammarGenerator() {
wadlGeneratorDelegate = new WadlGeneratorImpl();
}
public void setWadlGeneratorDelegate(final WadlGenerator delegate) {
wadlGeneratorDelegate = delegate;
}
public String getRequiredJaxbContextPath() {
return wadlGeneratorDelegate.getRequiredJaxbContextPath();
}
public void init() throws Exception {
wadlGeneratorDelegate.init();
seeAlsoClasses = new HashSet<>();
nameCallbacks = new ArrayList<>();
}
public Application createApplication() {
return wadlGeneratorDelegate.createApplication();
}
public Method createMethod(final org.glassfish.jersey.server.model.Resource ar,
final org.glassfish.jersey.server.model.ResourceMethod arm) {
return wadlGeneratorDelegate.createMethod(ar, arm);
}
public Request createRequest(final org.glassfish.jersey.server.model.Resource ar,
final org.glassfish.jersey.server.model.ResourceMethod arm) {
return wadlGeneratorDelegate.createRequest(ar, arm);
}
public Param createParam(final org.glassfish.jersey.server.model.Resource ar,
final org.glassfish.jersey.server.model.ResourceMethod am, final Parameter p) {
final Param param = wadlGeneratorDelegate.createParam(ar, am, p);
if (p.getSource() == Parameter.Source.ENTITY) {
nameCallbacks.add(new TypeCallbackPair(
new GenericType(p.getType()),
new NameCallbackSetter() {
public void setName(final QName name) {
param.setType(name);
}
}));
}
return param;
}
public Representation createRequestRepresentation(
final org.glassfish.jersey.server.model.Resource ar,
final org.glassfish.jersey.server.model.ResourceMethod arm,
final MediaType mt) {
final Representation rt = wadlGeneratorDelegate.createRequestRepresentation(ar, arm, mt);
for (final Parameter p : arm.getInvocable().getParameters()) {
if (p.getSource() == Parameter.Source.ENTITY) {
nameCallbacks.add(new TypeCallbackPair(
new GenericType(p.getType()),
new NameCallbackSetter() {
@Override
public void setName(final QName name) {
rt.setElement(name);
}
}));
}
}
return rt;
}
public Resource createResource(final org.glassfish.jersey.server.model.Resource ar, final String path) {
for (final Class<?> resClass : ar.getHandlerClasses()) {
final XmlSeeAlso seeAlso = resClass.getAnnotation(XmlSeeAlso.class);
if (seeAlso != null) {
Collections.addAll(seeAlsoClasses, seeAlso.value());
}
}
return wadlGeneratorDelegate.createResource(ar, path);
}
public Resources createResources() {
return wadlGeneratorDelegate.createResources();
}
public List<Response> createResponses(final org.glassfish.jersey.server.model.Resource resource,
final org.glassfish.jersey.server.model.ResourceMethod resourceMethod) {
final List<Response> responses = wadlGeneratorDelegate.createResponses(resource, resourceMethod);
if (responses != null) {
for (final Response response : responses) {
for (final Representation representation : response.getRepresentation()) {
nameCallbacks.add(new TypeCallbackPair(
new GenericType(resourceMethod.getInvocable().getResponseType()),
new NameCallbackSetter() {
public void setName(final QName name) {
representation.setElement(name);
}
}));
}
}
}
return responses;
}
public ExternalGrammarDefinition createExternalGrammar() {
final Map<String, ApplicationDescription.ExternalGrammar> extraFiles = new HashMap<>();
final Resolver resolver = buildModelAndSchemas(extraFiles);
final ExternalGrammarDefinition previous = wadlGeneratorDelegate.createExternalGrammar();
previous.map.putAll(extraFiles);
if (resolver != null) {
previous.addResolver(resolver);
}
return previous;
}
private Resolver buildModelAndSchemas(final Map<String, ApplicationDescription.ExternalGrammar> extraFiles) {
final Set<Class> classSet = new HashSet<>(seeAlsoClasses);
for (final TypeCallbackPair pair : nameCallbacks) {
final GenericType genericType = pair.genericType;
final Class<?> clazz = genericType.getRawType();
if (clazz.getAnnotation(XmlRootElement.class) != null) {
classSet.add(clazz);
} else if (SPECIAL_GENERIC_TYPES.contains(clazz)) {
final Type type = genericType.getType();
if (type instanceof ParameterizedType) {
final Type parameterType = ((ParameterizedType) type).getActualTypeArguments()[0];
if (parameterType instanceof Class) {
classSet.add((Class) parameterType);
}
}
}
}
JAXBIntrospector introspector = null;
try {
final JAXBContext context = JAXBContext.newInstance(classSet.toArray(new Class[classSet.size()]));
final List<StreamResult> results = new ArrayList<>();
context.generateSchema(new SchemaOutputResolver() {
int counter = 0;
@Override
public Result createOutput(final String namespaceUri, final String suggestedFileName) {
final StreamResult result = new StreamResult(new CharArrayWriter());
result.setSystemId("xsd" + (counter++) + ".xsd");
results.add(result);
return result;
}
});
for (final StreamResult result : results) {
final CharArrayWriter writer = (CharArrayWriter) result.getWriter();
final byte[] contents = writer.toString().getBytes("UTF8");
extraFiles.put(
result.getSystemId(),
new ApplicationDescription.ExternalGrammar(
MediaType.APPLICATION_XML_TYPE,
contents));
}
introspector = context.createJAXBIntrospector();
} catch (final JAXBException e) {
LOGGER.log(Level.SEVERE, "Failed to generate the schema for the JAX-B elements", e);
} catch (final IOException e) {
LOGGER.log(Level.SEVERE, "Failed to generate the schema for the JAX-B elements due to an IO error", e);
}
if (introspector != null) {
final JAXBIntrospector copy = introspector;
return new Resolver() {
public QName resolve(final Class type) {
Object parameterClassInstance = null;
try {
final Constructor<?> defaultConstructor =
AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
@SuppressWarnings("unchecked")
@Override
public Constructor<?> run() throws NoSuchMethodException {
final Constructor<?> constructor = type.getDeclaredConstructor();
constructor.setAccessible(true);
return constructor;
}
});
parameterClassInstance = defaultConstructor.newInstance();
} catch (final InstantiationException | SecurityException | IllegalAccessException
| IllegalArgumentException | InvocationTargetException ex) {
LOGGER.log(Level.FINE, null, ex);
} catch (final PrivilegedActionException ex) {
LOGGER.log(Level.FINE, null, ex.getCause());
}
if (parameterClassInstance == null) {
return null;
}
try {
return copy.getElementName(parameterClassInstance);
} catch (final NullPointerException e) {
return null;
}
}
};
} else {
return null;
}
}
public void attachTypes(final ApplicationDescription introspector) {
if (introspector != null) {
for (final TypeCallbackPair pair : nameCallbacks) {
Class<?> parameterClass = pair.genericType.getRawType();
if (SPECIAL_GENERIC_TYPES.contains(parameterClass)) {
final Type type = pair.genericType.getType();
if (ParameterizedType.class.isAssignableFrom(type.getClass())
&& Class.class.isAssignableFrom(((ParameterizedType) type).getActualTypeArguments()[0].getClass())) {
parameterClass = (Class) ((ParameterizedType) type).getActualTypeArguments()[0];
} else {
LOGGER.fine("Couldn't find JAX-B element due to nested parameterized type " + type);
return;
}
}
final QName name = introspector.resolve(parameterClass);
if (name != null) {
pair.nameCallbackSetter.setName(name);
} else {
LOGGER.fine("Couldn't find JAX-B element for class " + parameterClass.getName());
}
}
}
}
}