http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/244cc21a/org.apache.juneau.server/src/main/java/org/apache/juneau/server/RestServlet.java ---------------------------------------------------------------------- diff --git a/org.apache.juneau.server/src/main/java/org/apache/juneau/server/RestServlet.java b/org.apache.juneau.server/src/main/java/org/apache/juneau/server/RestServlet.java new file mode 100755 index 0000000..9b5bbb8 --- /dev/null +++ b/org.apache.juneau.server/src/main/java/org/apache/juneau/server/RestServlet.java @@ -0,0 +1,2795 @@ +/*************************************************************************************************************************** + * 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.juneau.server; + +import static java.lang.String.*; +import static java.util.logging.Level.*; +import static javax.servlet.http.HttpServletResponse.*; +import static org.apache.juneau.internal.ArrayUtils.*; +import static org.apache.juneau.internal.ClassUtils.*; +import static org.apache.juneau.serializer.SerializerContext.*; +import static org.apache.juneau.server.RestServlet.ParamType.*; +import static org.apache.juneau.server.RestServletContext.*; +import static org.apache.juneau.server.annotation.Inherit.*; + +import java.io.*; +import java.lang.annotation.Annotation; +import java.lang.reflect.*; +import java.lang.reflect.Method; +import java.nio.charset.*; +import java.text.*; +import java.util.*; +import java.util.concurrent.*; +import java.util.logging.*; + +import javax.activation.*; +import javax.servlet.*; +import javax.servlet.http.*; + +import org.apache.juneau.*; +import org.apache.juneau.encoders.*; +import org.apache.juneau.encoders.Encoder; +import org.apache.juneau.ini.*; +import org.apache.juneau.internal.*; +import org.apache.juneau.json.*; +import org.apache.juneau.parser.*; +import org.apache.juneau.parser.ParseException; +import org.apache.juneau.serializer.*; +import org.apache.juneau.server.annotation.*; +import org.apache.juneau.server.annotation.Properties; +import org.apache.juneau.server.annotation.Var; +import org.apache.juneau.server.labels.*; +import org.apache.juneau.server.response.*; +import org.apache.juneau.server.vars.*; +import org.apache.juneau.svl.*; +import org.apache.juneau.svl.vars.*; +import org.apache.juneau.urlencoding.*; +import org.apache.juneau.utils.*; + +/** + * Servlet implementation of a REST resource. + * <p> + * Refer to <a class='doclink' href='package-summary.html#TOC'>REST Servlet API</a> for information about using this class. + * </p> + * + * @author jbognar + */ +@SuppressWarnings({"rawtypes","hiding"}) +public abstract class RestServlet extends HttpServlet { + + private static final long serialVersionUID = 1L; + + static final SortedMap<String,Charset> availableCharsets = new TreeMap<String,Charset>(String.CASE_INSENSITIVE_ORDER); + static { + availableCharsets.putAll(Charset.availableCharsets()); + } + // Map of HTTP method names (e.g. GET/PUT/...) to ResourceMethod implementations for it. Populated during resource initialization. + private final Map<String,ResourceMethod> restMethods = new LinkedHashMap<String,ResourceMethod>(); + + // The list of all @RestMethod annotated methods in the order they appear in the class. + private final Map<String,MethodMeta> javaRestMethods = new LinkedHashMap<String,MethodMeta>(); + + // Child resources of this resource defined through getX() methods on this class. + private final Map<String,RestServlet> childResources = new LinkedHashMap<String,RestServlet>(); + + private RestServlet parentResource; + + private ServletConfig servletConfig; + private volatile boolean isInitialized = false; + private Exception initException; // Exception thrown by init() method (cached so it can be thrown on all subsequent requests). + private JuneauLogger logger; + private MessageBundle msgs; // NLS messages. + + private Map<Integer,Integer> stackTraceHashes = new HashMap<Integer,Integer>(); + private String path; + + private LinkedHashMap<Class<?>,RestResource> restResourceAnnotationsChildFirst, restResourceAnnotationsParentFirst; + + private UrlEncodingSerializer urlEncodingSerializer; + private UrlEncodingParser urlEncodingParser; + private ObjectMap properties; + private RestGuard[] guards; + private Class<?>[] transforms; + private RestConverter[] converters; + private TreeMap<String,String> defaultRequestHeaders; + private Map<String,Object> defaultResponseHeaders; + private EncoderGroup encoders; + private SerializerGroup serializers; + private ParserGroup parsers; + private MimetypesFileTypeMap mimetypesFileTypeMap; + private BeanContext beanContext; + private VarResolver varResolver; + private String label="", description=""; + private Map<String,byte[]> resourceStreams = new ConcurrentHashMap<String,byte[]>(); + private Map<String,String> resourceStrings = new ConcurrentHashMap<String,String>(); + private ConfigFile configFile, resolvingConfigFile; + private String configPath; + private StreamResource styleSheet, favIcon; + private Map<String,String> staticFilesMap; + private String[] staticFilesPrefixes; + private ResponseHandler[] responseHandlers; + private String clientVersionHeader = ""; + + RestServletContext context; + + // In-memory cache of images and stylesheets in the org.apache.juneau.server.htdocs package. + private Map<String,StreamResource> staticFilesCache = new ConcurrentHashMap<String,StreamResource>(); + + // The following code block is executed before the constructor is called to + // allow the config file to be accessed during object creation. + // e.g. private String myConfig = getConfig().getString("myConfig"); + { + varResolver = createVarResolver(); + + // @RestResource annotations from bottom to top. + restResourceAnnotationsChildFirst = ReflectionUtils.findAnnotationsMap(RestResource.class, getClass()); + + // @RestResource annotations from top to bottom. + restResourceAnnotationsParentFirst = CollectionUtils.reverse(restResourceAnnotationsChildFirst); + + for (RestResource r : restResourceAnnotationsParentFirst.values()) { + if (! r.config().isEmpty()) + configPath = r.config(); + } + + try { + configFile = createConfigFile(); + varResolver.setContextObject(ConfigFileVar.SESSION_config, configFile); + } catch (IOException e) { + this.initException = e; + } + } + + @Override /* Servlet */ + public synchronized void init(ServletConfig servletConfig) throws ServletException { + try { + log(FINE, "Servlet {0} init called.", getClass().getName()); + this.servletConfig = servletConfig; + + if (isInitialized) + return; + + super.init(servletConfig); + + // Find resource resource bundle location. + for (Map.Entry<Class<?>,RestResource> e : restResourceAnnotationsChildFirst.entrySet()) { + Class<?> c = e.getKey(); + RestResource r = e.getValue(); + if (! r.messages().isEmpty()) { + if (msgs == null) + msgs = new MessageBundle(c, r.messages()); + else + msgs.addSearchPath(c, r.messages()); + } + if (label.isEmpty()) + label = r.label(); + if (description.isEmpty()) + description = r.description(); + if (clientVersionHeader.isEmpty()) + clientVersionHeader = r.clientVersionHeader(); + } + if (msgs == null) + msgs = new MessageBundle(this.getClass(), ""); + if (clientVersionHeader.isEmpty()) + clientVersionHeader = "X-Client-Version"; + + styleSheet = createStyleSheet(); + favIcon = createFavIcon(); + staticFilesMap = Collections.unmodifiableMap(createStaticFilesMap()); + staticFilesPrefixes = staticFilesMap.keySet().toArray(new String[0]); + + properties = createProperties(); + transforms = createTransforms(); + context = ContextFactory.create().setProperties(properties).getContext(RestServletContext.class); + beanContext = createBeanContext(properties, transforms); + urlEncodingSerializer = createUrlEncodingSerializer(properties, transforms).lock(); + urlEncodingParser = createUrlEncodingParser(properties, transforms).lock(); + serializers = createSerializers(properties, transforms).lock(); + parsers = createParsers(properties, transforms).lock(); + converters = createConverters(properties); + encoders = createEncoders(properties); + guards = createGuards(properties); + mimetypesFileTypeMap = createMimetypesFileTypeMap(properties); + defaultRequestHeaders = new TreeMap<String,String>(String.CASE_INSENSITIVE_ORDER); + defaultRequestHeaders.putAll(createDefaultRequestHeaders(properties)); + defaultResponseHeaders = createDefaultResponseHeaders(properties); + responseHandlers = createResponseHandlers(properties); + + // Discover the @RestMethod methods available on the resource. + List<String> methodsFound = new LinkedList<String>(); // Temporary to help debug transient duplicate method issue. + for (java.lang.reflect.Method method : this.getClass().getMethods()) { + if (method.isAnnotationPresent(RestMethod.class)) { + RestMethod a = method.getAnnotation(RestMethod.class); + methodsFound.add(method.getName() + "," + a.name() + "," + a.path()); + try { + if (! Modifier.isPublic(method.getModifiers())) + throw new RestServletException("@RestMethod method {0}.{1} must be defined as public.", this.getClass().getName(), method.getName()); + + MethodMeta sm = new MethodMeta(method); + javaRestMethods.put(method.getName(), sm); + ResourceMethod rm = restMethods.get(sm.httpMethod); + if (rm == null) + restMethods.put(sm.httpMethod, sm); + else if (rm instanceof MultiMethod) + ((MultiMethod)rm).addSimpleMethod(sm); + else + restMethods.put(sm.httpMethod, new MultiMethod((MethodMeta)rm, sm)); + } catch (RestServletException e) { + throw new RestServletException("Problem occurred trying to serialize methods on class {0}, methods={1}", this.getClass().getName(), JsonSerializer.DEFAULT_LAX.serialize(methodsFound)).initCause(e); + } + } + } + + for (ResourceMethod m : restMethods.values()) + m.complete(); + + // Discover the child resources. + childResources.putAll(createChildrenMap()); + + for (RestServlet child : childResources.values()) + child.init(servletConfig); + + varResolver.addVars( + LocalizationVar.class, + RequestAttrVar.class, + RequestParamVar.class, + RequestVar.class, + SerializedRequestAttrVar.class, + SerializedRequestParamVar.class, + ServletInitParamVar.class, + UrlEncodeVar.class + ); + + } catch (RestException e) { + // Thrown RestExceptions are simply caught and rethrown on subsequent calls to service(). + initException = e; + log(SEVERE, e, "Servlet init error on class ''{0}''", getClass().getName()); + label = String.valueOf(initException.getLocalizedMessage()); + } catch (ServletException e) { + initException = e; + log(SEVERE, e, "Servlet init error on class ''{0}''", getClass().getName()); + label = String.valueOf(initException.getLocalizedMessage()); + throw e; + } catch (Exception e) { + initException = e; + log(SEVERE, e, "Servlet init error on class ''{0}''", getClass().getName()); + label = String.valueOf(initException.getLocalizedMessage()); + throw new ServletException(e); + } catch (Throwable e) { + initException = new Exception(e); + log(SEVERE, e, "Servlet init error on class ''{0}''", getClass().getName()); + label = String.valueOf(initException.getLocalizedMessage()); + throw new ServletException(e); + } finally { + isInitialized = true; + } + } + + //-------------------------------------------------------------------------------- + // Initialization methods + //-------------------------------------------------------------------------------- + + /** + * Creates the child resources of this resource. + * <p> + * Default implementation calls {@link #createChildren()} and uses the {@link RestResource#path() @RestResource.path()} annotation + * on each child to identify the subpath for the resource which become the keys in this map. + * It then calls the {@link #setParent(RestServlet)} method on the child resource. + * </p> + * <p> + * Subclasses can override this method to programatically create child resources + * without using the {@link RestResource#children() @RestResource.children()} annotation. + * When overridding this method, you are responsible for calling {@link #setParent(RestServlet)} on the + * child resources. + * </p> + * + * @return The new mutable list of child resource instances. + * @throws Exception If an error occurred during servlet instantiation. + */ + protected Map<String,RestServlet> createChildrenMap() throws Exception { + Map<String,RestServlet> m = new LinkedHashMap<String,RestServlet>(); + for (RestServlet r : createChildren()) { + r.setParent(this); + String p = r.findPath(); + if (p == null) + throw new RestServletException("Child resource ''{0}'' does not define a ''@RestResource.path'' attribute.", r.getClass().getName()); + m.put(p, r); + } + return m; + } + + /** + * Creates instances of child resources for this servlet. + * <p> + * Default implementation uses the {@link RestResource#children() @RestResource.children()} annotation to identify and + * instantiate children. + * </p> + * <p> + * Subclasses can override this method to programatically create child resources + * without using the {@link RestResource#children() @RestResource.children()} annotation. + * </p> + * + * @return The new mutable list of child resource instances. + * @throws Exception If an error occurred during servlet instantiation. + */ + protected List<RestServlet> createChildren() throws Exception { + List<RestServlet> l = new LinkedList<RestServlet>(); + for (Class<?> c : getChildClasses()) { + if (isParentClass(RestServlet.class, c)) + l.add((RestServlet)c.newInstance()); + else + l.add(resolveChild(c)); + } + return l; + } + + /** + * Programmatic equivalent to the {@link RestResource#children() @RestResource.children()} annotation. + * <p> + * Subclasses can override this method to provide customized list of child resources. + * (e.g. different children based on values specified in the config file). + * </p> + * <p> + * Default implementation simply returns the value from the {@link RestResource#children() @RestResource.children()} annotation. + * </p> + * + * @return The new mutable list of child resource instances. + * @throws Exception If an error occurred during servlet instantiation. + */ + protected Class<?>[] getChildClasses() throws Exception { + List<Class<?>> l = new ArrayList<Class<?>>(); + List<RestResource> rr = ReflectionUtils.findAnnotations(RestResource.class, getClass()); + for (RestResource r : rr) + l.addAll(Arrays.asList(r.children())); + return l.toArray(new Class<?>[l.size()]); + } + + /** + * Creates the class-level properties associated with this servlet. + * <p> + * Subclasses can override this method to provide their own class-level properties for this servlet, typically + * by calling <code><jk>super</jk>.createProperties()</code> and appending to the map. + * However, in most cases, the existing set of properties can be added to by overridding {@link #getProperties()} + * and appending to the map returned by <code><jk>super</jk>.getProperties()</code> + * </p> + * <p> + * By default, the map returned by this method contains the following: + * </p> + * <ul class='spaced-list'> + * <li>Servlet-init parameters. + * <li>{@link RestResource#properties()} annotations in parent-to-child order. + * <li>{@link SerializerContext#SERIALIZER_relativeUriBase} from {@link ServletConfig#getServletContext()}. + * </ul> + * + * @return The resource properties as an {@link ObjectMap}. + */ + protected ObjectMap createProperties() { + ObjectMap m = new ObjectMap(); + + ServletContext ctx = servletConfig.getServletContext(); + + // Workaround for bug in Jetty that causes context path to always end in "null". + String ctxPath = ctx.getContextPath(); + if (ctxPath.endsWith("null")) + ctxPath = ctxPath.substring(0, ctxPath.length()-4); + m.put(SERIALIZER_relativeUriBase, ctxPath); + + // Get the initialization parameters. + for (Enumeration ep = servletConfig.getInitParameterNames(); ep.hasMoreElements();) { + String p = (String)ep.nextElement(); + String initParam = servletConfig.getInitParameter(p); + m.put(p, initParam); + } + + // Properties are loaded in parent-to-child order to allow overrides. + for (RestResource r : restResourceAnnotationsParentFirst.values()) + for (Property p : r.properties()) + m.append(getVarResolver().resolve(p.name()), getVarResolver().resolve(p.value())); + + return m; + } + + /** + * Creates the class-level POJO transforms associated with this servlet. + * <p> + * Subclasses can override this method to provide their own class-level POJO transforms for this servlet. + * <p> + * By default, returns the transforms specified through the {@link RestResource#transforms() @RestResource.transforms()} annotation in child-to-parent order. + * (i.e. transforms will be applied in child-to-parent order with child annotations overriding parent annotations when + * the same transforms are applied). + * + * @return The new set of transforms associated with this servet. + */ + protected Class<?>[] createTransforms() { + List<Class<?>> l = new LinkedList<Class<?>>(); + + // Transforms are loaded in parent-to-child order to allow overrides. + for (RestResource r : restResourceAnnotationsChildFirst.values()) + for (Class c : r.transforms()) + l.add(c); + + return l.toArray(new Class<?>[l.size()]); + } + + /** + * Creates the {@link BeanContext} object used for parsing path variables and header values. + * <p> + * Subclasses can override this method to provide their own specialized bean context. + * + * @param properties Servlet-level properties returned by {@link #createProperties()}. + * @param transforms Servlet-level transforms returned by {@link #createTransforms()}. + * @return The new bean context. + * @throws Exception If bean context not be constructed for any reason. + */ + protected BeanContext createBeanContext(ObjectMap properties, Class<?>[] transforms) throws Exception { + return ContextFactory.create().addTransforms(transforms).setProperties(properties).getBeanContext(); + } + + /** + * Creates the URL-encoding serializer used for serializing object passed to {@link Redirect}. + * <p> + * Subclasses can override this method to provide their own specialized serializer. + * + * @param properties Servlet-level properties returned by {@link #createProperties()}. + * @param transforms Servlet-level transforms returned by {@link #createTransforms()}. + * @return The new URL-Encoding serializer. + * @throws Exception If the serializer could not be constructed for any reason. + */ + protected UrlEncodingSerializer createUrlEncodingSerializer(ObjectMap properties, Class<?>[] transforms) throws Exception { + return new UrlEncodingSerializer().setProperties(properties).addTransforms(transforms); + } + + /** + * Creates the URL-encoding parser used for parsing URL query parameters. + * <p> + * Subclasses can override this method to provide their own specialized parser. + * + * @param properties Servlet-level properties returned by {@link #createProperties()}. + * @param transforms Servlet-level transforms returned by {@link #createTransforms()}. + * @return The new URL-Encoding parser. + * @throws Exception If the parser could not be constructed for any reason. + */ + protected UrlEncodingParser createUrlEncodingParser(ObjectMap properties, Class<?>[] transforms) throws Exception { + return new UrlEncodingParser().setProperties(properties).addTransforms(transforms); + } + + /** + * Creates the serializer group containing serializers used for serializing output POJOs in HTTP responses. + * <p> + * Subclasses can override this method to provide their own set of serializers for this servlet. + * They can do this by either creating a new {@link SerializerGroup} from scratch, or appending to the + * group returned by <code><jk>super</jk>.createSerializers()</code>. + * <p> + * By default, returns the serializers defined through {@link RestResource#serializers() @RestResource.serializers()} on this class + * and all parent classes. + * + * @param properties Servlet-level properties returned by {@link #createProperties()}. + * @param transforms Servlet-level transforms returned by {@link #createTransforms()}. + * @return The group of serializers. + * @throws Exception If serializer group could not be constructed for any reason. + */ + protected SerializerGroup createSerializers(ObjectMap properties, Class<?>[] transforms) throws Exception { + SerializerGroup g = new SerializerGroup(); + + // Serializers are loaded in parent-to-child order to allow overrides. + for (RestResource r : restResourceAnnotationsParentFirst.values()) + for (Class<? extends Serializer> c : reverse(r.serializers())) + try { + g.append(c); + } catch (Exception e) { + throw new RestServletException("Exception occurred while trying to instantiate Serializer ''{0}''", c.getSimpleName()).initCause(e); + } + + g.setProperties(properties); + g.addTransforms(transforms); + return g; + } + + /** + * Creates the parser group containing parsers used for parsing input into POJOs from HTTP requests. + * <p> + * Subclasses can override this method to provide their own set of parsers for this servlet. + * They can do this by either creating a new {@link ParserGroup} from scratch, or appending to the + * group returned by <code><jk>super</jk>.createParsers()</code>. + * <p> + * By default, returns the parsers defined through {@link RestResource#parsers() @RestResource.parsers()} on this class + * and all parent classes. + * + * @param properties Servlet-level properties returned by {@link #createProperties()}. + * @param transforms Servlet-level transforms returned by {@link #createTransforms()}. + * @return The group of parsers. + * @throws Exception If parser group could not be constructed for any reason. + */ + protected ParserGroup createParsers(ObjectMap properties, Class<?>[] transforms) throws Exception { + ParserGroup g = new ParserGroup(); + + // Parsers are loaded in parent-to-child order to allow overrides. + for (RestResource r : restResourceAnnotationsParentFirst.values()) + for (Class<? extends Parser> p : reverse(r.parsers())) + try { + g.append(p); + } catch (Exception e) { + throw new RestServletException("Exception occurred while trying to instantiate Parser ''{0}''", p.getSimpleName()).initCause(e); + } + + g.setProperties(properties); + g.addTransforms(transforms); + return g; + } + + /** + * Creates the class-level converters associated with this servlet. + * <p> + * Subclasses can override this method to provide their own class-level converters for this servlet. + * <p> + * By default, returns the converters specified through the {@link RestResource#converters() @RestResource.converters()} annotation in child-to-parent order. + * (e.g. converters on children will be called before converters on parents). + * + * @param properties Servlet-level properties returned by {@link #createProperties()}. + * @return The new set of transforms associated with this servet. + * @throws RestServletException + */ + protected RestConverter[] createConverters(ObjectMap properties) throws RestServletException { + List<RestConverter> l = new LinkedList<RestConverter>(); + + // Converters are loaded in child-to-parent order. + for (RestResource r : restResourceAnnotationsChildFirst.values()) + for (Class<? extends RestConverter> c : r.converters()) + try { + l.add(c.newInstance()); + } catch (Exception e) { + throw new RestServletException("Exception occurred while trying to instantiate RestConverter ''{0}''", c.getSimpleName()).initCause(e); + } + + return l.toArray(new RestConverter[l.size()]); + } + + /** + * Creates the {@link EncoderGroup} for this servlet for handling various encoding schemes. + * <p> + * Subclasses can override this method to provide their own encoder group, typically by + * appending to the group returned by <code><jk>super</jk>.createEncoders()</code>. + * <p> + * By default, returns a group containing {@link IdentityEncoder#INSTANCE} and all encoders + * specified through {@link RestResource#encoders() @RestResource.encoders()} annotations in parent-to-child order. + * + * @param properties Servlet-level properties returned by {@link #createProperties()}. + * @return The new encoder group associated with this servet. + * @throws RestServletException + */ + protected EncoderGroup createEncoders(ObjectMap properties) throws RestServletException { + EncoderGroup g = new EncoderGroup().append(IdentityEncoder.INSTANCE); + + // Encoders are loaded in parent-to-child order to allow overrides. + for (RestResource r : restResourceAnnotationsParentFirst.values()) + for (Class<? extends Encoder> c : reverse(r.encoders())) + try { + g.append(c); + } catch (Exception e) { + throw new RestServletException("Exception occurred while trying to instantiate Encoder ''{0}''", c.getSimpleName()).initCause(e); + } + + return g; + } + + /** + * Creates the class-level guards associated with this servlet. + * <p> + * Subclasses can override this method to provide their own class-level guards for this servlet. + * <p> + * By default, returns the guards specified through the {@link RestResource#guards() @RestResource.guards()} annotation in child-to-parent order. + * (i.e. guards on children will be called before guards on parents). + * + * @param properties Servlet-level properties returned by {@link #createProperties()}. + * @return The new set of guards associated with this servet. + * @throws RestServletException + */ + protected RestGuard[] createGuards(ObjectMap properties) throws RestServletException { + List<RestGuard> l = new LinkedList<RestGuard>(); + + // Guards are loaded in child-to-parent order. + for (RestResource r : restResourceAnnotationsChildFirst.values()) + for (Class<? extends RestGuard> c : reverse(r.guards())) + try { + l.add(c.newInstance()); + } catch (Exception e) { + throw new RestServletException("Exception occurred while trying to instantiate RestGuard ''{0}''", c.getSimpleName()).initCause(e); + } + + return l.toArray(new RestGuard[l.size()]); + } + + /** + * Creates an instance of {@link MimetypesFileTypeMap} that is used to determine + * the media types of static files. + * <p> + * Subclasses can override this method to provide their own mappings, or augment the existing + * map by appending to <code><jk>super</jk>.createMimetypesFileTypeMap()</code> + * + * @param properties Servlet-level properties returned by {@link #createProperties()}. + * @return A new reusable MIME-types map. + */ + protected MimetypesFileTypeMap createMimetypesFileTypeMap(ObjectMap properties) { + MimetypesFileTypeMap m = new MimetypesFileTypeMap(); + m.addMimeTypes("text/css css CSS"); + m.addMimeTypes("text/html html htm HTML"); + m.addMimeTypes("text/plain txt text TXT"); + m.addMimeTypes("application/javascript js"); + m.addMimeTypes("image/png png"); + m.addMimeTypes("image/gif gif"); + m.addMimeTypes("application/xml xml XML"); + m.addMimeTypes("application/json json JSON"); + return m; + } + + /** + * Creates the set of default request headers for this servlet. + * <p> + * Default request headers are default values for when HTTP requests do not specify a header value. + * For example, you can specify a default value for <code>Accept</code> if a request does not specify that header value. + * <p> + * Subclasses can override this method to provide their own class-level default request headers for this servlet. + * <p> + * By default, returns the default request headers specified through the {@link RestResource#defaultRequestHeaders() @RestResource.defaultRequestHeaders()} + * annotation in parent-to-child order. + * (e.g. headers defined on children will override the same headers defined on parents). + * + * @param properties Servlet-level properties returned by {@link #createProperties()}. + * @return The new set of default request headers associated with this servet. + * @throws RestServletException + */ + protected Map<String,String> createDefaultRequestHeaders(ObjectMap properties) throws RestServletException { + Map<String,String> m = new HashMap<String,String>(); + + // Headers are loaded in parent-to-child order to allow overrides. + for (RestResource r : restResourceAnnotationsParentFirst.values()) { + for (String s : r.defaultRequestHeaders()) { + String[] h = parseHeader(s); + if (h == null) + throw new RestServletException("Invalid default request header specified: ''{0}''. Must be in the format: ''Header-Name: header-value''", s); + m.put(h[0], h[1]); + } + } + + return m; + } + + /** + * Creates the set of default response headers for this servlet. + * <p> + * Default response headers are headers that will be appended to all responses if those headers have not already been + * set on the response object. + * <p> + * Subclasses can override this method to provide their own class-level default response headers for this servlet. + * <p> + * By default, returns the default response headers specified through the {@link RestResource#defaultResponseHeaders() @RestResource.defaultResponseHeaders()} + * annotation in parent-to-child order. + * (e.g. headers defined on children will override the same headers defined on parents). + * + * @param properties Servlet-level properties returned by {@link #createProperties()}. + * @return The new set of default response headers associated with this servet. + * @throws RestServletException + */ + protected Map<String,Object> createDefaultResponseHeaders(ObjectMap properties) throws RestServletException { + Map<String,Object> m = new LinkedHashMap<String,Object>(); + + // Headers are loaded in parent-to-child order to allow overrides. + for (RestResource r : restResourceAnnotationsParentFirst.values()) { + for (String s : r.defaultResponseHeaders()) { + String[] h = parseHeader(s); + if (h == null) + throw new RestServletException("Invalid default response header specified: ''{0}''. Must be in the format: ''Header-Name: header-value''", s); + m.put(h[0], h[1]); + } + } + + return m; + } + + /** + * Creates the class-level response handlers associated with this servlet. + * <p> + * Subclasses can override this method to provide their own class-level response handlers for this servlet. + * <p> + * By default, returns the handlers specified through the {@link RestResource#responseHandlers() @RestResource.responseHandlers()} + * annotation in parent-to-child order. + * (e.g. handlers on children will be called before handlers on parents). + * + * @param properties Servlet-level properties returned by {@link #createProperties()}. + * @return The new set of response handlers associated with this servet. + * @throws RestException + */ + protected ResponseHandler[] createResponseHandlers(ObjectMap properties) throws RestException { + List<ResponseHandler> l = new LinkedList<ResponseHandler>(); + + // Loaded in parent-to-child order to allow overrides. + for (RestResource r : restResourceAnnotationsParentFirst.values()) + for (Class<? extends ResponseHandler> c : r.responseHandlers()) + try { + l.add(c.newInstance()); + } catch (Exception e) { + throw new RestException(SC_INTERNAL_SERVER_ERROR, e); + } + + // Add the default handlers. + l.add(new StreamableHandler()); + l.add(new WritableHandler()); + l.add(new ReaderHandler()); + l.add(new InputStreamHandler()); + l.add(new RedirectHandler()); + l.add(new DefaultHandler()); + + return l.toArray(new ResponseHandler[l.size()]); + } + + + //-------------------------------------------------------------------------------- + // Other methods + //-------------------------------------------------------------------------------- + + /** + * Sets the parent of this resource. + * + * @param parent The parent of this resource. + */ + protected void setParent(RestServlet parent) { + this.parentResource = parent; + } + + /** + * Returns the parent of this resource. + * + * @return The parent of this resource, or <jk>null</jk> if resource has no parent. + */ + public RestServlet getParent() { + return this.parentResource; + } + + private String[] parseHeader(String s) { + int i = s.indexOf(':'); + if (i == -1) + return null; + String name = s.substring(0, i).trim().toLowerCase(Locale.ENGLISH); + String val = s.substring(i+1).trim(); + return new String[]{name,val}; + } + + /** + * Creates a {@link RestRequest} object based on the specified incoming {@link HttpServletRequest} object. + * <p> + * Subclasses may choose to override this method to provide a specialized request object. + * </p> + * + * @param req The request object from the {@link #service(HttpServletRequest, HttpServletResponse)} method. + * @return The wrapped request object. + * @throws ServletException If any errors occur trying to interpret the request. + */ + protected RestRequest createRequest(HttpServletRequest req) throws ServletException { + return new RestRequest(this, req); + } + + /** + * Creates a {@link RestResponse} object based on the specified incoming {@link HttpServletResponse} object + * and the request returned by {@link #createRequest(HttpServletRequest)}. + * <p> + * Subclasses may choose to override this method to provide a specialized response object. + * </p> + * + * @param req The request object returned by {@link #createRequest(HttpServletRequest)}. + * @param res The response object from the {@link #service(HttpServletRequest, HttpServletResponse)} method. + * @return The wrapped response object. + * @throws ServletException If any erros occur trying to interpret the request or response. + */ + protected RestResponse createResponse(RestRequest req, HttpServletResponse res) throws ServletException { + return new RestResponse(this, req, res); + } + + /** + * Returns whether this resource class can provide an OPTIONS page. + * <p> + * By default, returns <jk>false</jk>. + * </p> + * <p> + * Subclasses can override this method to cause the <code>options</code> link to show up in the HTML serialized output. + * </p> + * + * @return <jk>true</jk> if this resource has implemented a {@code getOptions()} method. + */ + public boolean hasOptionsPage() { + return false; + } + + /** + * Specify a class-level property. + * <p> + * Typically, properties in {@link RestServletContext} can be set in the {@link Servlet#init(ServletConfig)} method. + * </p> + * + * @param key The property name. + * @param value The property value. + * @return This object (for method chaining). + */ + public synchronized RestServlet setProperty(String key, Object value) { + getProperties().put(key, value); + return this; + } + + /** + * The main service method. + * <p> + * Subclasses can optionally override this method if they want to tailor the behavior of requests. + * </p> + */ + @Override /* Servlet */ + public void service(HttpServletRequest r1, HttpServletResponse r2) throws ServletException, IOException { + + log(FINE, "HTTP: {0} {1}", r1.getMethod(), r1.getRequestURI()); + long startTime = System.currentTimeMillis(); + + try { + + if (initException != null) { + if (initException instanceof RestException) + throw (RestException)initException; + throw new RestException(SC_INTERNAL_SERVER_ERROR, initException); + } + + if (! isInitialized) + throw new RestException(SC_INTERNAL_SERVER_ERROR, "Servlet has not been initialized"); + + String pathInfo = RestUtils.getPathInfoUndecoded(r1); // Can't use r1.getPathInfo() because we don't want '%2F' resolved. + + // If this resource has child resources, try to recursively call them. + if (pathInfo != null && (! childResources.isEmpty()) && (! pathInfo.equals("/"))) { + int i = pathInfo.indexOf('/', 1); + String pathInfoPart = i == -1 ? pathInfo.substring(1) : pathInfo.substring(1, i); + RestServlet childResource = childResources.get(pathInfoPart); + if (childResource != null) { + final String pathInfoRemainder = (i == -1 ? null : pathInfo.substring(i)); + final String servletPath = r1.getServletPath() + "/" + pathInfoPart; + final HttpServletRequest childRequest = new HttpServletRequestWrapper(r1) { + @Override /* ServletRequest */ + public String getPathInfo() { + return RestUtils.decode(pathInfoRemainder); + } + @Override /* ServletRequest */ + public String getServletPath() { + return servletPath; + } + }; + childResource.service(childRequest, r2); + return; + } + } + + RestRequest req = createRequest(r1); + RestResponse res = createResponse(req, r2); + String method = req.getMethod(); + String methodUC = method.toUpperCase(Locale.ENGLISH); + + StreamResource r = null; + if (pathInfo != null) { + String p = pathInfo.substring(1); + if (p.equals("favicon.ico")) + r = favIcon; + else if (p.equals("style.css")) + r = styleSheet; + else if (StringUtils.pathStartsWith(p, staticFilesPrefixes)) + r = resolveStaticFile(p); + } + + if (r != null) { + res.setStatus(SC_OK); + res.setOutput(r); + } else { + // If the specified method has been defined in a subclass, invoke it. + int rc = SC_METHOD_NOT_ALLOWED; + if (restMethods.containsKey(methodUC)) { + rc = restMethods.get(methodUC).invoke(method, pathInfo, this, req, res); + } else if (restMethods.containsKey("*")) { + rc = restMethods.get("*").invoke(method, pathInfo, this, req, res); + } + + // If not invoked above, see if it's an OPTIONs request + if (rc != SC_OK) + handleNotFound(rc, req, res); + } + + if (res.hasOutput()) { + Object output = res.getOutput(); + + // Do any class-level transforming. + for (RestConverter converter : getConverters()) + output = converter.convert(req, output, getBeanContext().getClassMetaForObject(output)); + + res.setOutput(output); + + // Now serialize the output if there was any. + // Some subclasses may write to the OutputStream or Writer directly. + handleResponse(req, res, output); + } + + onSuccess(req, res, System.currentTimeMillis() - startTime); + + } catch (RestException e) { + handleError(r1, r2, e); + } catch (Throwable e) { + handleError(r1, r2, new RestException(SC_INTERNAL_SERVER_ERROR, e)); + } + log(FINE, "HTTP: [{0} {1}] finished in {2}ms", r1.getMethod(), r1.getRequestURI(), System.currentTimeMillis()-startTime); + } + + /** + * Handle the case where a matching method was not found. + * <p> + * Subclasses can override this method to provide a 2nd-chance for specifying a response. + * The default implementation will simply throw an exception with an appropriate message. + * </p> + * + * @param rc The HTTP response code. + * @param req The HTTP request. + * @param res The HTTP response. + * @throws Exception + */ + protected void handleNotFound(int rc, RestRequest req, RestResponse res) throws Exception { + String pathInfo = req.getPathInfo(); + String methodUC = req.getMethod(); + String onPath = pathInfo == null ? " on no pathInfo" : format(" on path '%s'", pathInfo); + if (rc == SC_NOT_FOUND) + throw new RestException(rc, "Method ''{0}'' not found on resource with matching pattern{1}.", methodUC, onPath); + else if (rc == SC_PRECONDITION_FAILED) + throw new RestException(rc, "Method ''{0}'' not found on resource{1} with matching matcher.", methodUC, onPath); + else if (rc == SC_METHOD_NOT_ALLOWED) + throw new RestException(rc, "Method ''{0}'' not found on resource.", methodUC); + else + throw new ServletException("Invalid method response: " + rc); + } + + private synchronized void handleError(HttpServletRequest req, HttpServletResponse res, RestException e) throws IOException { + Integer c = 1; + if (context.useStackTraceHashes) { + int h = e.hashCode(); + c = stackTraceHashes.get(h); + if (c == null) + c = 1; + else + c++; + stackTraceHashes.put(h, c); + e.setOccurrence(c); + } + onError(req, res, e); + renderError(req, res, e); + } + + /** + * Method for rendering response errors. + * <p> + * The default implementation renders a plain text English message, optionally with a stack trace + * if {@link RestServletContext#REST_renderResponseStackTraces} is enabled. + * </p> + * <p> + * Subclasses can override this method to provide their own custom error response handling. + * </p> + * + * @param req The servlet request. + * @param res The servlet response. + * @param e The exception that occurred. + * @throws IOException Can be thrown if a problem occurred trying to write to the output stream. + */ + protected void renderError(HttpServletRequest req, HttpServletResponse res, RestException e) throws IOException { + + int status = e.getStatus(); + res.setStatus(status); + res.setContentType("text/plain"); + res.setHeader("Content-Encoding", "identity"); + PrintWriter w = null; + try { + w = res.getWriter(); + } catch (IllegalStateException e2) { + w = new PrintWriter(new OutputStreamWriter(res.getOutputStream(), IOUtils.UTF8)); + } + String httpMessage = RestUtils.getHttpResponseText(status); + if (httpMessage != null) + w.append("HTTP ").append(String.valueOf(status)).append(": ").append(httpMessage).append("\n\n"); + if (context.renderResponseStackTraces) + e.printStackTrace(w); + else + w.append(e.getFullStackMessage(true)); + w.flush(); + w.close(); + } + + /** + * Callback method for logging errors during HTTP requests. + * <p> + * Typically, subclasses will override this method and log errors themselves. + * <p> + * </p> + * The default implementation simply logs errors to the <code>RestServlet</code> logger. + * </p> + * <p> + * Here's a typical implementation showing how stack trace hashing can be used to reduce log file sizes... + * </p> + * <p class='bcode'> + * <jk>protected void</jk> onError(HttpServletRequest req, HttpServletResponse res, RestException e, <jk>boolean</jk> noTrace) { + * String qs = req.getQueryString(); + * String msg = <js>"HTTP "</js> + req.getMethod() + <js>" "</js> + e.getStatus() + <js>" "</js> + req.getRequestURI() + (qs == <jk>null</jk> ? <js>""</js> : <js>"?"</js> + qs); + * <jk>int</jk> c = e.getOccurrence(); + * + * <jc>// REST_useStackTraceHashes is disabled, so we have to log the exception every time.</jc> + * <jk>if</jk> (c == 0) + * myLogger.log(Level.<jsf>WARNING</jsf>, <jsm>format</jsm>(<js>"[%s] %s"</js>, e.getStatus(), msg), e); + * + * <jc>// This is the first time we've countered this error, so log a stack trace + * // unless ?noTrace was passed in as a URL parameter.</jc> + * <jk>else if</jk> (c == 1 && ! noTrace) + * myLogger.log(Level.<jsf>WARNING</jsf>, <jsm>format</jsm>(<js>"[%h.%s.%s] %s"</js>, e.hashCode(), e.getStatus(), c, msg), e); + * + * <jc>// This error occurred before. + * // Only log the message, not the stack trace.</jc> + * <jk>else</jk> + * myLogger.log(Level.<jsf>WARNING</jsf>, <jsm>format</jsm>(<js>"[%h.%s.%s] %s, %s"</js>, e.hashCode(), e.getStatus(), c, msg, e.getLocalizedMessage())); + * } + * </p> + * + * @param req The servlet request object. + * @param res The servlet response object. + * @param e Exception indicating what error occurred. + */ + protected void onError(HttpServletRequest req, HttpServletResponse res, RestException e) { + if (shouldLog(req, res, e)) { + String qs = req.getQueryString(); + String msg = "HTTP " + req.getMethod() + " " + e.getStatus() + " " + req.getRequestURI() + (qs == null ? "" : "?" + qs); + int c = e.getOccurrence(); + if (shouldLogStackTrace(req, res, e)) { + msg = '[' + Integer.toHexString(e.hashCode()) + '.' + e.getStatus() + '.' + c + "] " + msg; + log(Level.WARNING, e, msg); + } else { + msg = '[' + Integer.toHexString(e.hashCode()) + '.' + e.getStatus() + '.' + c + "] " + msg + ", " + e.getLocalizedMessage(); + log(Level.WARNING, msg); + } + } + } + + /** + * Returns <jk>true</jk> if the specified exception should be logged. + * <p> + * Subclasses can override this method to provide their own logic for determining when exceptions are logged. + * </p> + * <p> + * The default implementation will return <jk>false</jk> if <js>"noTrace=true"</js> is passed in the query string. + * </p> + * + * @param req The HTTP request. + * @param res The HTTP response. + * @param e The exception. + * @return <jk>true</jk> if exception should be logged. + */ + protected boolean shouldLog(HttpServletRequest req, HttpServletResponse res, RestException e) { + String q = req.getQueryString(); + return (q == null ? true : q.indexOf("noTrace=true") == -1); + } + + /** + * Returns <jk>true</jk> if a stack trace should be logged for this exception. + * <p> + * Subclasses can override this method to provide their own logic for determining when stack traces are logged. + * </p> + * <p> + * The default implementation will only log a stack trace if {@link RestException#getOccurrence()} returns <code>1</code> + * and the exception is not one of the following: + * </p> + * <ul> + * <li>{@link HttpServletResponse#SC_UNAUTHORIZED} + * <li>{@link HttpServletResponse#SC_FORBIDDEN} + * <li>{@link HttpServletResponse#SC_NOT_FOUND} + * </ul> + * + * @param req The HTTP request. + * @param res The HTTP response. + * @param e The exception. + * @return <jk>true</jk> if stack trace should be logged. + */ + protected boolean shouldLogStackTrace(HttpServletRequest req, HttpServletResponse res, RestException e) { + if (e.getOccurrence() == 1) { + switch (e.getStatus()) { + case SC_UNAUTHORIZED: + case SC_FORBIDDEN: + case SC_NOT_FOUND: return false; + default: return true; + } + } + return false; + } + + /** + * Log a message. + * <p> + * Equivalent to calling <code>log(level, <jk>null</jk>, msg, args);</code> + * </p> + * + * @param level The log level. + * @param msg The message to log. + * @param args {@link MessageFormat} style arguments in the message. + */ + protected void log(Level level, String msg, Object...args) { + log(level, null, msg, args); + } + + /** + * Same as {@link #log(Level, String, Object...)} excepts runs the + * arguments through {@link JsonSerializer#DEFAULT_LAX_READABLE}. + * <p> + * Serialization of arguments do not occur if message is not logged, so + * it's safe to use this method from within debug log statements. + * </p> + * + * <dl> + * <dt>Example:</dt> + * <dd> + * <p class='bcode'> + * logObjects(<jsf>DEBUG</jsf>, <js>"Pojo contents:\n{0}"</js>, myPojo); + * </p> + * </dd> + * </dl> + * + * @param level The log level. + * @param msg The message to log. + * @param args {@link MessageFormat} style arguments in the message. + */ + protected void logObjects(Level level, String msg, Object...args) { + for (int i = 0; i < args.length; i++) + args[i] = JsonSerializer.DEFAULT_LAX_READABLE.toStringObject(args[i]); + log(level, null, msg, args); + } + + /** + * Log a message to the logger returned by {@link #getLogger()}. + * <p> + * Subclasses can override this method if they wish to log messages using a library other than + * Java Logging (e.g. Apache Commons Logging). + * </p> + * + * @param level The log level. + * @param cause The cause. + * @param msg The message to log. + * @param args {@link MessageFormat} style arguments in the message. + */ + protected void log(Level level, Throwable cause, String msg, Object...args) { + JuneauLogger log = getLogger(); + if (args.length > 0) + msg = MessageFormat.format(msg, args); + log.log(level, msg, cause); + } + + /** + * Callback method for listening for successful completion of requests. + * <p> + * Subclasses can override this method for gathering performance statistics. + * </p> + * <p> + * The default implementation does nothing. + * </p> + * + * @param req The HTTP request. + * @param res The HTTP response. + * @param time The time in milliseconds it took to process the request. + */ + protected void onSuccess(RestRequest req, RestResponse res, long time) {} + + /** + * Callback method that gets invoked right before the REST Java method is invoked. + * <p> + * Subclasses can override this method to override request headers or set request-duration properties + * before the Java method is invoked. + * </p> + * + * @param req The HTTP servlet request object. + * @throws RestException If any error occurs. + */ + protected void onPreCall(RestRequest req) throws RestException {} + + /** + * Callback method that gets invoked right after the REST Java method is invoked, but before + * the serializer is invoked. + * <p> + * Subclasses can override this method to override request and response headers, or + * set/override properties used by the serializer. + * </p> + * + * @param req The HTTP servlet request object. + * @param res The HTTP servlet response object. + * @throws RestException If any error occurs. + */ + protected void onPostCall(RestRequest req, RestResponse res) throws RestException {} + + /** + * The main method for serializing POJOs passed in through the {@link RestResponse#setOutput(Object)} method. + * <p> + * Subclasses may override this method if they wish to modify the way the output is rendered, or support + * other output formats. + * </p> + * + * @param req The HTTP request. + * @param res The HTTP response. + * @param output The output to serialize in the response. + * @throws IOException + * @throws RestException + */ + protected void handleResponse(RestRequest req, RestResponse res, Object output) throws IOException, RestException { + // Loop until we find the correct handler for the POJO. + for (ResponseHandler h : getResponseHandlers()) + if (h.handle(req, res, output)) + return; + throw new RestException(SC_NOT_IMPLEMENTED, "No response handlers found to process output of type '"+(output == null ? null : output.getClass().getName())+"'"); + } + + @Override /* GenericServlet */ + public ServletConfig getServletConfig() { + return servletConfig; + } + + @Override /* GenericServlet */ + public void destroy() { + for (RestServlet r : childResources.values()) + r.destroy(); + super.destroy(); + } + + /** + * Resolve a static resource file. + * <p> + * Subclasses can override this method to provide their own way to resolve files. + * </p> + * + * @param pathInfo The unencoded path info. + * @return The resource, or <jk>null</jk> if the resource could not be resolved. + * @throws IOException + */ + protected StreamResource resolveStaticFile(String pathInfo) throws IOException { + if (! staticFilesCache.containsKey(pathInfo)) { + String p = RestUtils.decode(RestUtils.trimSlashes(pathInfo)); + if (p.indexOf("..") != -1) + throw new RestException(SC_NOT_FOUND, "Invalid path"); + for (Map.Entry<String,String> e : staticFilesMap.entrySet()) { + String key = RestUtils.trimSlashes(e.getKey()); + if (p.startsWith(key)) { + String remainder = (p.equals(key) ? "" : p.substring(key.length())); + if (remainder.isEmpty() || remainder.startsWith("/")) { + String p2 = RestUtils.trimSlashes(e.getValue()) + remainder; + InputStream is = getResource(p2); + if (is != null) { + try { + int i = p2.lastIndexOf('/'); + String name = (i == -1 ? p2 : p2.substring(i+1)); + String mediaType = getMimetypesFileTypeMap().getContentType(name); + staticFilesCache.put(pathInfo, new StreamResource(is, mediaType).setHeader("Cache-Control", "max-age=86400, public")); + return staticFilesCache.get(pathInfo); + } finally { + is.close(); + } + } + } + } + } + } + return staticFilesCache.get(pathInfo); + } + + /** + * Returns a list of valid {@code Accept} content types for this resource. + * <p> + * Typically used by subclasses during {@code OPTIONS} requests. + * </p> + * <p> + * The default implementation resturns the list from {@link ParserGroup#getSupportedMediaTypes()} + * from the parser group returned by {@link #getParsers()}. + * </p> + * <p> + * Subclasses can override or expand this list as they see fit. + * </p> + * + * @return The list of valid {@code Accept} content types for this resource. + * @throws RestServletException + */ + public Collection<String> getSupportedAcceptTypes() throws RestServletException { + return getParsers().getSupportedMediaTypes(); + } + + /** + * Returns a list of valid {@code Content-Types} for input for this resource. + * <p> + * Typically used by subclasses during {@code OPTIONS} requests. + * </p> + * <p> + * The default implementation resturns the list from {@link SerializerGroup#getSupportedMediaTypes()} + * from the parser group returned by {@link #getSerializers()}. + * </p> + * <p> + * Subclasses can override or expand this list as they see fit. + * </p> + * + * @return The list of valid {@code Content-Type} header values for this resource. + * @throws RestServletException + */ + public Collection<String> getSupportedContentTypes() throws RestServletException { + return getSerializers().getSupportedMediaTypes(); + } + + /** + * Returns localized descriptions of all REST methods defined on this class that the user of the current + * request is allowed to access. + * <p> + * Useful for OPTIONS pages. + * </p> + * <p> + * This method does not cache results, since it's expected to be called infrequently. + * </p> + * + * @param req The current request. + * @return Localized descriptions of all REST methods defined on this class. + * @throws RestServletException + */ + public Collection<MethodDescription> getMethodDescriptions(RestRequest req) throws RestServletException { + List<MethodDescription> l = new LinkedList<MethodDescription>(); + for (MethodMeta sm : javaRestMethods.values()) + if (sm.isRequestAllowed(req)) + l.add(getMethodDescription(sm.method, sm, req)); + return l; + } + + /** + * Returns the localized description of this REST resource. + * <p> + * Subclasses can override this method to provide their own description. + * </p> + * <p> + * The default implementation returns the description from the following locations (whichever matches first): + * </p> + * <ol> + * <li>{@link RestResource#description() @RestResource.description()} annotation on this class, and then any parent classes. + * <li><ck>[ClassName].description</ck> property in resource bundle identified by {@link RestResource#messages() @RestResource.messages()} + * annotation for this class, then any parent classes. + * <li><ck>description</ck> property in resource bundle identified by {@link RestResource#messages() @RestResource.messages()} + * annotation for this class, then any parent classes. + * </ol> + * + * @param req The current request. + * @return The localized description of this REST resource, or a blank string if no resource description was found. + */ + public String getDescription(RestRequest req) { + if (! description.isEmpty()) + return req.getVarResolverSession().resolve(description); + String description = msgs.findFirstString(req.getLocale(), "description"); + return (description == null ? "" : req.getVarResolverSession().resolve(description)); + } + + /** + * Returns the localized description of the specified java method on this servlet. + * <p> + * Subclasses can override this method to provide their own description. + * </p> + * <p> + * The default implementation returns the description from the following locations (whichever matches first): + * </p> + * <ol> + * <li>{@link RestMethod#description() @RestMethod.description()} annotation on the method. + * <li><ck>[ClassName].[javaMethodName]</ck> property in resource bundle identified by {@link RestResource#messages() @RestResource.messages()} + * annotation for this class, then any parent classes. + * <li><ck>[javaMethodName]</ck> property in resource bundle identified by {@link RestResource#messages() @RestResource.messages()} + * annotation for this class, then any parent classes. + * </ol> + * + * @param javaMethodName The name of the Java method whose description we're retrieving. + * @param req The current request. + * @return The localized description of the method, or a blank string if no description was found. + */ + public String getMethodDescription(String javaMethodName, RestRequest req) { + MethodMeta m = javaRestMethods.get(javaMethodName); + if (m != null) + return m.getDescription(req); + return ""; + } + + /** + * Returns the localized label of this REST resource. + * <p> + * Subclasses can override this method to provide their own description. + * </p> + * <p> + * The default implementation returns the description from the following locations (whichever matches first): + * </p> + * <ol> + * <li>{@link RestResource#label() @RestResourcel.label()} annotation on this class, and then any parent classes. + * <li><ck>[ClassName].label</ck> property in resource bundle identified by {@link RestResource#messages() @ResourceBundle.messages()} + * annotation for this class, then any parent classes. + * <li><ck>label</ck> in resource bundle identified by {@link RestResource#messages() @RestResource.messages()} + * annotation for this class, then any parent classes. + * </ol> + * + * @param req The current request. + * @return The localized description of this REST resource, or a blank string if no resource description was found. + */ + public String getLabel(RestRequest req) { + if (! label.isEmpty()) + return req.getVarResolverSession().resolve(label); + String label = msgs.findFirstString(req.getLocale(), "label"); + return (label == null ? "" : req.getVarResolverSession().resolve(label)); + } + + /** + * Returns the resource bundle identified by the {@link RestResource#messages() @RestResource.messages()} annotation for the default locale. + * + * @return The resource bundle. Never <jk>null</jk>. + */ + public MessageBundle getMessages() { + return msgs; + } + + /** + * Returns the resource bundle identified by the {@link RestResource#messages() @RestResource.messages()} annotation for the specified locale. + * + * @param locale The resource bundle locale. + * @return The resource bundle. Never <jk>null</jk>. + */ + public MessageBundle getMessages(Locale locale) { + return msgs.getBundle(locale); + } + + /** + * Gets a localized message from the resource bundle identified by the {@link RestResource#messages() @RestResource.messages()} annotation. + * <p> + * If resource bundle location was not specified, or the resource bundle was not found, + * returns the string <js>"{!!key}"</js>. + * </p> + * <p> + * If message was not found in the resource bundle, returns the string <js>"{!key}"</js>. + * </p> + * + * @param locale The client locale. + * @param key The resource bundle key. + * @param args Optional {@link java.text.MessageFormat} variable values to replace. + * @return The localized message. + */ + public String getMessage(Locale locale, String key, Object...args) { + return msgs.getString(locale, key, args); + } + + /** + * Programmatically adds the specified resource as a child to this resource. + * <p> + * This method can be used in a resources {@link #init()} method to define child resources + * accessible through a child URL. + * </p> + * <p> + * Typically, child methods are defined via {@link RestResource#children() @RestResource.children()}. However, this + * method is provided to handle child resources determined at runtime. + * </p> + * + * @param name The sub-URL under which this resource is accessible.<br> + * For example, if the parent resource URL is <js>"/foo"</js>, and this name is <js>"bar"</js>, then + * the child resource will be accessible via the URL <js>"/foo/bar"</js>. + * @param resource The child resource. + * @throws ServletException Thrown by the child init() method. + */ + protected void addChildResource(String name, RestServlet resource) throws ServletException { + resource.init(getServletConfig()); + childResources.put(name, resource); + } + + /** + * Returns the child resources associated with this servlet. + * + * @return An unmodifiable map of child resources. + * Keys are the {@link RestResource#path() @RestResource.path()} annotation defined on the child resource. + */ + public Map<String,RestServlet> getChildResources() { + return Collections.unmodifiableMap(childResources); + } + + /** + * Returns the path for this servlet as defined by the {@link RestResource#path()} annotation + * on this class concatenated with those on all parent classes. + * <p> + * If path is not specified, returns <js>"/"</js>. + * </p> + * <p> + * Path always starts with <js>"/"</js>. + * </p> + * + * @return The servlet path. + */ + public String getPath() { + if (path == null) { + LinkedList<String> l = new LinkedList<String>(); + RestServlet r = this; + while (r != null) { + String p = r.findPath(); + if (p == null) + break; + l.addFirst(p); + r = r.parentResource; + } + StringBuilder sb = new StringBuilder(); + for (String p : l) + sb.append('/').append(p); + path = sb.toString(); + } + return path; + } + + private String findPath() { + List<RestResource> rrc = ReflectionUtils.findAnnotations(RestResource.class, getClass()); + for (RestResource rc : rrc) { + String p = rc.path(); + if (StringUtils.startsWith(p, '/')) + p = p.substring(1); + if (! p.isEmpty()) + return p; + } + return null; + } + + /** + * Returns the config file for this servlet. + * <p> + * Subclasses can override this method to provide their own config file. + * </p> + * <p> + * The default implementation uses the path defined by the {@link RestResource#config() @RestResource.config()} property resolved + * by {@link ConfigMgr#DEFAULT}. + * </p> + * + * @return The config file for this servlet. + * @throws IOException + */ + protected ConfigFile createConfigFile() throws IOException { + String cf = varResolver.resolve(configPath); + if (cf.isEmpty()) + return getConfigMgr().create(); + return getConfigMgr().get(cf); + } + + /** + * Creates the stylesheet for this servlet. + * <p> + * The stylesheet is made available on the path <js>"/servlet-path/style.css"</js>. + * </p> + * <p> + * Subclasses can override this method to provide their own stylesheet. + * </p> + * <p> + * The default implementation uses the {@link RestResource#stylesheet() @RestResource.stylesheet()} annotation + * to determine the stylesheet name and then searches the classpath then working directory + * for that stylesheet. + * </p> + * + * @return The stylesheet to use for this servlet, or <jk>null</jk> if the stylesheet could not be found. + * @throws IOException If stylesheet could not be loaded. + */ + protected StreamResource createStyleSheet() throws IOException { + for (RestResource r : restResourceAnnotationsChildFirst.values()) { + if (! r.stylesheet().isEmpty()) { + String path = getVarResolver().resolve(r.stylesheet()); + InputStream is = getResource(path); + if (is != null) { + try { + return new StreamResource(is, "text/css"); + } finally { + is.close(); + } + } + } + } + return null; + } + + /** + * Creates the favicon for this servlet. + * <p> + * The favicon is made available on the path <js>"/servlet-path/favicon.ico"</js>. + * </p> + * <p> + * Subclasses can override this method to provide their own favorites icon. + * </p> + * <p> + * The default implementation uses the {@link RestResource#favicon() @RestResource.favicon()} annotation + * to determine the file name and then searches the classpath then working directory + * for that file. + * </p> + * + * @return The icon file to use for this servlet. + * @throws IOException If icon file could not be loaded. + */ + protected StreamResource createFavIcon() throws IOException { + for (RestResource r : restResourceAnnotationsChildFirst.values()) { + if (! r.favicon().isEmpty()) { + String path = getVarResolver().resolve(r.favicon()); + InputStream is = getResource(path); + if (is != null) { + try { + return new StreamResource(is, "image/x-icon"); + } finally { + is.close(); + } + } + } + } + return null; + } + + /** + * Creates the static files map for this servlet. + * <p> + * This map defines static files that can be served up through subpaths on this servlet. + * The map keys are subpaths (e.g. <js>"htdocs"</js>) and the values are locations to look in + * the classpath and working directory for those files. + * </p> + * <p> + * Subclasses can override this method to provide their own mappings. + * </p> + * <p> + * The default implementation uses the {@link RestResource#staticFiles() @RestResource.staticFiles()} annotation + * to determine the mappings. + * </p> + * + * @return The list of static file mappings. + * @throws ParseException + */ + @SuppressWarnings("unchecked") + protected Map<String,String> createStaticFilesMap() throws ParseException { + Map<String,String> m = new LinkedHashMap<String,String>(); + for (RestResource r : restResourceAnnotationsParentFirst.values()) + if (! r.staticFiles().isEmpty()) + m.putAll(JsonParser.DEFAULT.parseMap(getVarResolver().resolve(r.staticFiles()), LinkedHashMap.class, String.class, String.class)); + return m; + } + + /** + * Returns the config manager used to create the config file in {@link #createConfigFile()}. + * <p> + * The default implementation return {@link ConfigMgr#DEFAULT}, but subclasses can override + * this if they want to provide their own customized config manager. + * </p> + * + * @return The config file manager. + */ + protected ConfigMgr getConfigMgr() { + return ConfigMgr.DEFAULT; + } + + /** + * Returns the logger associated with this servlet. + * <p> + * Subclasses can override this method to provide their own Java Logging logger. + * </p> + * <p> + * Subclasses that use other logging libraries such as Apache Commons Logging should + * override the {@link #log(Level, Throwable, String, Object...)} method instead. + * </p> + * + * @return The logger associated with this servlet. + */ + protected JuneauLogger getLogger() { + if (logger == null) + logger = JuneauLogger.getLogger(getClass()); + return logger; + } + + private abstract class ResourceMethod { + abstract int invoke(String methodName, String pathInfo, RestServlet resource, RestRequest req, RestResponse res) throws RestException; + + void complete() { + // Do nothing by default. + } + } + + static enum ParamType { + REQ, RES, ATTR, CONTENT, HEADER, METHOD, PARAM, QPARAM, HASPARAM, HASQPARAM, PATHREMAINDER, PROPS, MESSAGES; + + boolean isOneOf(ParamType...pt) { + for (ParamType ptt : pt) + if (this == ptt) + return true; + return false; + } + } + + static class MethodParam { + + ParamType paramType; + Type type; + String name = ""; + boolean multiPart, plainParams; + + MethodParam(MethodMeta mm, Type type, Method method, Annotation[] annotations) throws ServletException { + this.type = type; + boolean isClass = type instanceof Class; + if (isClass && isParentClass(HttpServletRequest.class, (Class)type)) + paramType = REQ; + else if (isClass && isParentClass(HttpServletResponse.class, (Class)type)) + paramType = RES; + else for (Annotation a : annotations) { + if (a instanceof Attr) { + Attr a2 = (Attr)a; + paramType = ATTR; + name = a2.value(); + } else if (a instanceof Header) { + Header h = (Header)a; + paramType = HEADER; + name = h.value(); + } else if (a instanceof Param) { + Param p = (Param)a; + if (p.multipart()) + assertCollection(type, method); + paramType = PARAM; + multiPart = p.multipart(); + plainParams = p.format().equals("INHERIT") ? mm.mPlainParams : p.format().equals("PLAIN"); + name = p.value(); + } else if (a instanceof QParam) { + QParam p = (QParam)a; + if (p.multipart()) + assertCollection(type, method); + paramType = QPARAM; + multiPart = p.multipart(); + plainParams = p.format().equals("INHERIT") ? mm.mPlainParams : p.format().equals("PLAIN"); + name = p.value(); + } else if (a instanceof HasParam) { + HasParam p = (HasParam)a; + paramType = HASPARAM; + name = p.value(); + } else if (a instanceof HasQParam) { + HasQParam p = (HasQParam)a; + paramType = HASQPARAM; + name = p.value(); + } else if (a instanceof Content) { + paramType = CONTENT; + } else if (a instanceof org.apache.juneau.server.annotation.Method) { + paramType = METHOD; + if (type != String.class) + throw new ServletException("@Method parameters must be of type String"); + } else if (a instanceof PathRemainder) { + paramType = PATHREMAINDER; + if (type != String.class) + throw new ServletException("@PathRemainder parameters must be of type String"); + } else if (a instanceof Properties) { + paramType = PROPS; + name = "PROPERTIES"; + } else if (a instanceof Messages) { + paramType = MESSAGES; + name = "MESSAGES"; + } + } + if (paramType == null) + paramType = ATTR; + } + + /** + * Throws an exception if the specified type isn't an array or collection. + */ + private void assertCollection(Type t, Method m) throws ServletException { + ClassMeta<?> cm = BeanContext.DEFAULT.getClassMeta(t); + if (! (cm.isArray() || cm.isCollection())) + throw new ServletException("Use of multipart flag on parameter that's not an array or Collection on method" + m); + } + + @SuppressWarnings("unchecked") + private Object getValue(RestRequest req, RestResponse res) throws Exception { + BeanContext bc = req.getServlet().getBeanContext(); + switch(paramType) { + case REQ: return req; + case RES: return res; + case ATTR: return req.getAttribute(name, type); + case CONTENT: return req.getInput(type); + case HEADER: return req.getHeader(name, type); + case METHOD: return req.getMethod(); + case PARAM: { + if (multiPart) + return req.getParameters(name, type); + if (plainParams) + return bc.convertToType(req.getParameter(name), bc.getClassMeta(type)); + return req.getParameter(name, type); + } + case QPARAM: { + if (multiPart) + return req.getQueryParameters(name, type); + if (plainParams) + return bc.convertToType(req.getQueryParameter(name), bc.getClassMeta(type)); + return req.getQueryParameter(name, type); + } + case HASPARAM: return bc.convertToType(req.hasParameter(name), bc.getClassMeta(type)); + case HASQPARAM: return bc.convertToType(req.hasQueryParameter(name), bc.getClassMeta(type)); + case PATHREMAINDER: return req.getPathRemainder(); + case PROPS: return res.getProperties(); + case MESSAGES: return req.getResourceBundle(); + } + return null; + } + } + + /* + * Represents a single Java servlet method annotated with @RestMethod. + */ + private class MethodMeta extends ResourceMethod implements Comparable<MethodMeta> { + private String httpMethod; + private java.lang.reflect.Method method; + private UrlPathPattern pathPattern; + private MethodParam[] params; + private RestGuard[] guards; + private RestMatcher[] optionalMatchers, requiredMatchers; + private RestConverter[] mConverters; + private SerializerGroup mSerializers; // Method-level serializers + private ParserGroup mParsers; // Method-level parsers + private EncoderGroup mEncoders; // Method-level encoders + private UrlEncodingParser mUrlEncodingParser; // Method-level URL parameter parser. + private UrlEncodingSerializer mUrlEncodingSerializer; // Method-level URL parameter serializer. + private ObjectMap mProperties; // Method-level properties + private Map<String,String> mDefaultRequestHeaders; // Method-level default request headers + private String mDefaultEncoding; + private boolean mPlainParams; + private String description; + private Integer priority; + + private MethodMeta(java.lang.reflect.Method method) throws RestServletException { + try { + this.method = method; + + RestMethod m = method.getAnnotation(RestMethod.class); + if (m == null) + throw new RestServletException("@RestMethod annotation not found on method ''{0}.{1}''", method.getDeclaringClass().getName(), method.getName()); + + this.description = m.description(); + this.mSerializers = getSerializers(); + this.mParsers = getParsers(); + this.mUrlEncodingParser = getUrlEncodingParser(); + this.mUrlEncodingSerializer = getUrlEncodingSerializer(); + this.mProperties = getProperties(); + this.mEncoders = getEncoders(); + + ArrayList<Inherit> si = new ArrayList<Inherit>(Arrays.asList(m.serializersInherit())); + ArrayList<Inherit> pi = new ArrayList<Inherit>(Arrays.asList(m.parsersInherit())); + + if (m.serializers().length > 0 || m.parsers().length > 0 || m.properties().length > 0 || m.transforms().length > 0) { + mSerializers = (si.contains(SERIALIZERS) || m.serializers().length == 0 ? mSerializers.clone() : new SerializerGroup()); + mParsers = (pi.contains(PARSERS) || m.parsers().length == 0 ? mParsers.clone() : new ParserGroup()); + mUrlEncodingParser = mUrlEncodingParser.clone(); + } + + httpMethod = m.name().toUpperCase(Locale.ENGLISH); + if (httpMethod.equals("") && method.getName().startsWith("do")) + httpMethod = method.getName().substring(2).toUpperCase(Locale.ENGLISH); + if (httpMethod.equals("")) + throw new RestServletException("@RestMethod name not specified on method ''{0}.{1}''", method.getDeclaringClass().getName(), method.getName()); + if (httpMethod.equals("METHOD")) + httpMethod = "*"; + + priority = m.priority(); + + String p = m.path(); + mConverters = new RestConverter[m.converters().length]; + for (int i = 0; i < mConverters.length; i++) + mConverters[i] = m.converters()[i].newInstance(); + + guards = new RestGuard[m.guards().length]; + for (int i = 0; i < guards.length; i++) + guards[i] = m.guards()[i].newInstance(); + + List<RestMatcher> optionalMatchers = new LinkedList<RestMatcher>(), requiredMatchers = new LinkedList<RestMatcher>(); + for (int i = 0; i < m.matchers().length; i++) { + Class<? extends RestMatcher> c = m.matchers()[i]; + RestMatcher matcher = null; + if (ClassUtils.isParentClass(RestMatcherReflecting.class, c)) + matcher = c.getConstructor(RestServlet.class, Method.class).newInstance(RestServlet.this, method); + else + matcher = c.newInstance(); + if (matcher.mustMatch()) + requiredMatchers.add(matcher); + else + optionalMatchers.add(matcher); + } + if (! m.clientVersion().isEmpty()) + requiredMatchers.add(new ClientVersionMatcher(RestServlet.this, method)); + + this.requiredMatchers = requiredMatchers.toArray(new RestMatcher[requiredMatchers.size()]); + this.optionalMatchers = optionalMatchers.toArray(new RestMatcher[optionalMatchers.size()]); + + if (m.serializers().length > 0) { + mSerializers.append(m.serializers()); + if (si.contains(TRANSFORMS)) + mSerializers.addTransforms(getTransforms()); + if (si.contains(PROPERTIES)) + mSerializers.setProperties(getProperties()); + } + + if (m.parsers().length > 0) { + mParsers.append(m.parsers()); + if (pi.contains(TRANSFORMS)) + mParsers.addTransforms(getTransforms()); + if (pi.contains(PROPERTIES)) + mParsers.setProperties(getProperties()); + } + + if (m.properties().length > 0) { + mProperties = new ObjectMap().setInner(getProperties()); + for (Property p1 : m.properties()) { + String n = p1.name(), v = p1.value(); + mProperties.put(n, v); + mSerializers.setProperty(n, v); + mParsers.setProperty(n, v); + mUrlEncodingParser.setProperty(n, v); + } + } + + if (m.transforms().length > 0) { + mSerializers.addTransforms(m.transforms()); + mParsers.addTransforms(m.transforms()); + mUrlEncodingParser.addTransforms(m.transforms()); + } + + if (m.encoders().length > 0 || ! m.inheritEncoders()) { + EncoderGroup g = new EncoderGroup(); + if (m.inheritEncoders()) + g.append(mEncoders); + else + g.append(IdentityEncoder.INSTANCE); + + for (Class<? extends Encoder> c : m.encoders()) { + try { + g.append(c); + } catch (Exception e) { + throw new RestServletException("Exception occurred while trying to instantiate Encoder ''{0}''", c.getSimpleName()).initCause(e); + } + } + mEncoders = g; + } + + mDefaultRequestHeaders = new TreeMap<String,String>(String.CASE_INSENSITIVE_ORDER); + for (String s : m.defaultRequestHeaders()) { + String[] h = parseHeader(s); + if (h == null) + throw new RestServletException("Invalid default request header specified: ''{0}''. Must be in the format: ''Header-Name: header-value''", s); + mDefaultRequestHeaders.put(h[0], h[1]); + } + + mDefaultEncoding = mProperties.getString(REST_defaultCharset, RestServlet.this.context.defaultCharset); + String paramFormat = mProperties.getString(REST_paramFormat, RestServlet.this.context.paramFormat); + mPlainParams = paramFormat.equals("PLAIN"); + + pathPattern = new UrlPathPattern(p); + + int attrIdx = 0; + Type[] pt = method.getGenericParameterTypes(); + Annotation[][] pa = method.getParameterAnnotations(); + params = new MethodParam[pt.length]; + for (int i = 0; i < params.length; i++) { + params[i] = new MethodParam(this, pt[i], method, pa[i]); + if (params[i].paramType == ATTR && params[i].name.isEmpty()) { + if (pathPattern.vars.length <= attrIdx) + throw new RestServletException("Number of attribute parameters in method ''{0}'' exceeds the number of URL pattern variables.", method.getName()); + params[i].name = pathPattern.vars[attrIdx++]; + } + } + + mSerializers.lock(); + mParsers.lock(); + mUrlEncodingParser.lock(); + + // Need this to access methods in anonymous inner classes. + method.setAccessible(true); + } catch (Exception e) { + throw new RestServletException("Exception occurred while initializing method ''{0}''", method.getName()).initCause(e); + } + } + + private String getDescription(RestRequest req) { + if (! description.isEmpty()) + return req.getVarResolverSession().resolve(description); + String description = msgs.findFirstString(req.getLocale(), method.getName()); + return (description == null ? "" : req.getVarResolverSession().resolve(description)); + } + + private boolean isRequestAllowed(RestRequest req) { + for (RestGuard guard : guards) { + req.javaMethod = method; + if (! guard.isRequestAllowed(req)) + return false; + } + return true; + } + + @Override /* ResourceMethod */ + int invoke(String methodName, String pathInfo, RestServlet resource, RestRequest req, RestResponse res) throws RestException { + + String[] patternVals = pathPattern.match(pathInfo); + if (patternVals == null) + return SC_NOT_FOUND; + + String remainder = null; + if (patternVals.length > pathPattern.vars.length) + remainder = patternVals[pathPattern.vars.length]; + for (int i = 0; i < pathPattern.vars.length; i++) + req.setAttribute(pathPattern.vars[i], patternVals[i]); + + req.init(method, remainder, createRequestProperties(mProperties, req), mDefaultRequestHeaders, mDefaultEncoding, mSerializers, mParsers, mUrlEncodingParser); + res.init(req.getProperties(), mDefaultEncoding, mSerializers, mUrlEncodingSerializer, mEncoders); + + // Class-level guards + for (RestGuard guard : getGuards()) + if (! guard.guard(req, res)) + return SC_UNAUTHORIZED; + + // If the method implements matchers, test them. + for (RestMatcher m : requiredMatchers) + if (! m.matches(req)) + return SC_PRECONDITION_FAILED; + if (optionalMatchers.length > 0) { + boolean matches = false; + for (RestMatcher m : optionalMatchers) + matches |= m.matches(req); + if (! matches) + return SC_PRECONDITION_FAILED; + } + + onPreCall(req); + + Object[] args = new Object[params.length]; + for (int i = 0; i < params.length; i++) { + try { + args[i] = params[i].getValue(req, res); + } catch (RestException e) { + throw e; + } catch (Exception e) { + throw new RestException(SC_BAD_REQUEST, + "Invalid data conversion. Could not convert {0} ''{1}'' to type ''{2}'' on method ''{3}.{4}''.", + params[i].paramType.name(), params[i].name, params[i].type, method.getDeclaringClass().getName(), method.getName() + ).initCause(e); + } + } + + try { + + for (RestGuard guard : guards) + if (! guard.guard(req, res)) + return SC_OK; + + Object output = method.invoke(resource, args); + if (! method.getReturnType().equals(Void.TYPE)) + if (output != null || ! res.getOutputStreamCalled()) + res.setOutput(output); + + onPostCall(req, res); + + if (res.hasOutput()) { + output = res.getOutput(); + for (RestConverter converter : mConverters) + output = converter.convert(req, output, getBeanContext().getClassMetaForObject(output)); + res.setOutput(output); + } + } catch (IllegalArgumentException e) { + throw new RestException(SC_BAD_REQUEST, + "Invalid argument type passed to the following method: ''{0}''.\n\tArgument types: {1}", + method.toString(), ClassUtils.getReadableClassNames(args) + ); + } catch (InvocationTargetException e) { + Throwable e2 = e.getTargetException(); // Get the throwable thrown from the doX() method. + if (e2 instanceof RestException) + throw (RestException)e2; + if (e2 instanceof ParseException) + throw new RestException(SC_BAD_REQUEST, e2); + if (e2 instanceof InvalidDataConversionException) + throw new RestException(SC_BAD_REQUEST, e2); + throw new RestException(SC_INTERNAL_SERVER_ERROR, e2); + } catch (RestException e) { + throw e; + } catch (Exception e) { + throw new RestException(SC_INTERNAL_SERVER_ERROR, e); + } + return SC_OK; + } + + @Override /* Object */ + public String toString() { + return "SimpleMethod: name=" + httpMethod + ", path=" + pathPattern.patternString; + } + + /* + * compareTo() method is used to keep SimpleMethods ordered in the MultiMethod.tempCache list. + * It maintains the order in which matches are made during requests. + */ + @Override /* Comparable */ + public int compareTo(MethodMeta o) { + int c; + + c = priority.compareTo(o.priority); + if (c != 0) + return c; + + c = pathPattern.compareTo(o.pathPattern); + if (c != 0) + return c; + + c = Utils.compare(o.requiredMatchers.length, requiredMatchers.length); + if (c != 0) + return c; + + c = Utils.compare(o.optionalMatchers.length, optionalMatchers.length); + if (c != 0) + return c; + + c = Utils.compare(o.guards.length, guards.length); + if (c != 0) + return c; + + return 0; + } + + @Override /* Object */ + public boolean equals(Object o) { + if (! (o instanceof MethodMeta)) + return false; + return (compareTo((MethodMeta)o) == 0); + } + + @Override /* Object */ + public int hashCode() { + return super.hashCode(); + } + } + + /* + * Represents a group of SimpleMethods that all belong to the same HTTP method (e.g. "GET"). + */ + private class MultiMethod extends ResourceMethod { + MethodMeta[] childMethods; + List<MethodMeta> tempCache = new LinkedList<MethodMeta>(); + Set<String> collisions = new HashSet<String>(); + + private MultiMethod(MethodMeta... simpleMethods) throws RestServletException { + for (MethodMeta m : simpleMethods) + addSimpleMethod(m); + } + + private void addSimpleMethod(MethodMeta m) throws RestServletException { + if (m.guards.length == 0 && m.requiredMatchers.length == 0 && m.optionalMatchers.length == 0) { + String p = m.httpMethod + ":" + m.pathPattern.toRegEx(); + if (collisions.contains(p)) + throw new RestServletException("Duplicate Java methods assigned to the same method/pattern: method=''{0}'', path=''{1}''", m.httpMethod, m.pathPattern); + collisions.add(p); + } + tempCache.add(m); + } + + @Override /* ResourceMethod */ + void complete() { + Collections.sort(tempCache); + collisions = null; + childMethods = tempCache.toArray(new MethodMeta[tempCache.size()]); + } + + @Override /* ResourceMethod */ + int invoke(String methodName, String pathInfo, RestServlet resource, RestRequest req, RestResponse res) throws RestException { + int maxRc = 0; + for (MethodMeta m : childMethods) { + int rc = m.invoke(methodName, pathInfo, resource, req, res); + //if (rc == SC_UNAUTHORIZED) + // return SC_UNAUTHORIZED; + if (rc == SC_OK) + return SC_OK; + maxRc = Math.max(maxRc, rc); + } + return maxRc; + } + + @Override /* Object */ + public String toString() { + StringBuilder sb = new StringBuilder("MultiMethod: [\n"); + for (MethodMeta sm : childMethods) + sb.append("\t" + sm + "\n"); + sb.append("]"); + return sb.toString(); + } + } + + /** + * Returns the method description for the specified method for the OPTIONS page of this servlet. + * <p> + * Subclasses can
<TRUNCATED>
