org.eclipse.jetty.servlet.ServletContextHandler Maven / Gradle / Ivy
//
// ========================================================================
// Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.servlet;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.EventListener;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.servlet.DispatcherType;
import javax.servlet.Filter;
import javax.servlet.FilterRegistration;
import javax.servlet.RequestDispatcher;
import javax.servlet.Servlet;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;
import javax.servlet.ServletSecurityElement;
import javax.servlet.SessionCookieConfig;
import javax.servlet.SessionTrackingMode;
import javax.servlet.descriptor.JspConfigDescriptor;
import javax.servlet.descriptor.JspPropertyGroupDescriptor;
import javax.servlet.descriptor.TaglibDescriptor;
import org.eclipse.jetty.security.ConstraintAware;
import org.eclipse.jetty.security.ConstraintMapping;
import org.eclipse.jetty.security.ConstraintSecurityHandler;
import org.eclipse.jetty.security.SecurityHandler;
import org.eclipse.jetty.server.Dispatcher;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.HandlerContainer;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.handler.ErrorHandler;
import org.eclipse.jetty.server.handler.HandlerCollection;
import org.eclipse.jetty.server.handler.HandlerWrapper;
import org.eclipse.jetty.server.session.SessionHandler;
import org.eclipse.jetty.util.LazyList;
import org.eclipse.jetty.util.security.Constraint;
/* ------------------------------------------------------------ */
/** Servlet Context.
* This extension to the ContextHandler allows for
* simple construction of a context with ServletHandler and optionally
* session and security handlers, et.
* new ServletContext("/context",Context.SESSIONS|Context.NO_SECURITY);
*
*
* This class should have been called ServletContext, but this would have
* cause confusion with {@link ServletContext}.
*/
public class ServletContextHandler extends ContextHandler
{
public final static int SESSIONS=1;
public final static int SECURITY=2;
public final static int NO_SESSIONS=0;
public final static int NO_SECURITY=0;
protected final List _decorators= new ArrayList();
protected Class _defaultSecurityHandlerClass=org.eclipse.jetty.security.ConstraintSecurityHandler.class;
protected SessionHandler _sessionHandler;
protected SecurityHandler _securityHandler;
protected ServletHandler _servletHandler;
protected HandlerWrapper _wrapper;
protected int _options;
protected JspConfigDescriptor _jspConfig;
protected Object _restrictedContextListeners;
private boolean _restrictListeners = true;
/* ------------------------------------------------------------ */
public ServletContextHandler()
{
this(null,null,null,null,null);
}
/* ------------------------------------------------------------ */
public ServletContextHandler(int options)
{
this(null,null,options);
}
/* ------------------------------------------------------------ */
public ServletContextHandler(HandlerContainer parent, String contextPath)
{
this(parent,contextPath,null,null,null,null);
}
/* ------------------------------------------------------------ */
public ServletContextHandler(HandlerContainer parent, String contextPath, int options)
{
this(parent,contextPath,null,null,null,null);
_options=options;
}
/* ------------------------------------------------------------ */
public ServletContextHandler(HandlerContainer parent, String contextPath, boolean sessions, boolean security)
{
this(parent,contextPath,(sessions?SESSIONS:0)|(security?SECURITY:0));
}
/* ------------------------------------------------------------ */
public ServletContextHandler(HandlerContainer parent, SessionHandler sessionHandler, SecurityHandler securityHandler, ServletHandler servletHandler, ErrorHandler errorHandler)
{
this(parent,null,sessionHandler,securityHandler,servletHandler,errorHandler);
}
/* ------------------------------------------------------------ */
public ServletContextHandler(HandlerContainer parent, String contextPath, SessionHandler sessionHandler, SecurityHandler securityHandler, ServletHandler servletHandler, ErrorHandler errorHandler)
{
super((ContextHandler.Context)null);
_scontext = new Context();
_sessionHandler = sessionHandler;
_securityHandler = securityHandler;
_servletHandler = servletHandler;
if (errorHandler!=null)
setErrorHandler(errorHandler);
if (contextPath!=null)
setContextPath(contextPath);
if (parent instanceof HandlerWrapper)
((HandlerWrapper)parent).setHandler(this);
else if (parent instanceof HandlerCollection)
((HandlerCollection)parent).addHandler(this);
}
/* ------------------------------------------------------------ */
/**
* @see org.eclipse.jetty.server.handler.ContextHandler#doStop()
*/
@Override
protected void doStop() throws Exception
{
super.doStop();
if (_decorators != null)
_decorators.clear();
if (_wrapper != null)
_wrapper.setHandler(null);
}
/* ------------------------------------------------------------ */
/** Get the defaultSecurityHandlerClass.
* @return the defaultSecurityHandlerClass
*/
public Class getDefaultSecurityHandlerClass()
{
return _defaultSecurityHandlerClass;
}
/* ------------------------------------------------------------ */
/** Set the defaultSecurityHandlerClass.
* @param defaultSecurityHandlerClass the defaultSecurityHandlerClass to set
*/
public void setDefaultSecurityHandlerClass(Class defaultSecurityHandlerClass)
{
_defaultSecurityHandlerClass = defaultSecurityHandlerClass;
}
/* ------------------------------------------------------------ */
protected SessionHandler newSessionHandler()
{
return new SessionHandler();
}
/* ------------------------------------------------------------ */
protected SecurityHandler newSecurityHandler()
{
try
{
return (SecurityHandler)_defaultSecurityHandlerClass.newInstance();
}
catch(Exception e)
{
throw new IllegalStateException(e);
}
}
/* ------------------------------------------------------------ */
protected ServletHandler newServletHandler()
{
return new ServletHandler();
}
/* ------------------------------------------------------------ */
/**
* Finish constructing handlers and link them together.
*
* @see org.eclipse.jetty.server.handler.ContextHandler#startContext()
*/
protected void startContext() throws Exception
{
// force creation of missing handlers.
getSessionHandler();
getSecurityHandler();
getServletHandler();
Handler handler = _servletHandler;
if (_securityHandler!=null)
{
_securityHandler.setHandler(handler);
handler=_securityHandler;
}
if (_sessionHandler!=null)
{
_sessionHandler.setHandler(handler);
handler=_sessionHandler;
}
// skip any wrapped handlers
_wrapper=this;
while (_wrapper!=handler && _wrapper.getHandler() instanceof HandlerWrapper)
_wrapper=(HandlerWrapper)_wrapper.getHandler();
// if we are not already linked
if (_wrapper!=handler)
{
if (_wrapper.getHandler()!=null )
throw new IllegalStateException("!ScopedHandler");
_wrapper.setHandler(handler);
}
super.startContext();
// OK to Initialize servlet handler now
if (_servletHandler != null && _servletHandler.isStarted())
{
for (int i=_decorators.size()-1;i>=0; i--)
{
Decorator decorator = _decorators.get(i);
if (_servletHandler.getFilters()!=null)
for (FilterHolder holder:_servletHandler.getFilters())
decorator.decorateFilterHolder(holder);
if(_servletHandler.getServlets()!=null)
for (ServletHolder holder:_servletHandler.getServlets())
decorator.decorateServletHolder(holder);
}
_servletHandler.initialize();
}
}
/* ------------------------------------------------------------ */
/**
* @return Returns the securityHandler.
*/
public SecurityHandler getSecurityHandler()
{
if (_securityHandler==null && (_options&SECURITY)!=0 && !isStarted())
_securityHandler=newSecurityHandler();
return _securityHandler;
}
/* ------------------------------------------------------------ */
/**
* @return Returns the servletHandler.
*/
public ServletHandler getServletHandler()
{
if (_servletHandler==null && !isStarted())
_servletHandler=newServletHandler();
return _servletHandler;
}
/* ------------------------------------------------------------ */
/**
* @return Returns the sessionHandler.
*/
public SessionHandler getSessionHandler()
{
if (_sessionHandler==null && (_options&SESSIONS)!=0 && !isStarted())
_sessionHandler=newSessionHandler();
return _sessionHandler;
}
/* ------------------------------------------------------------ */
/** conveniance method to add a servlet.
*/
public ServletHolder addServlet(String className,String pathSpec)
{
return getServletHandler().addServletWithMapping(className, pathSpec);
}
/* ------------------------------------------------------------ */
/** conveniance method to add a servlet.
*/
public ServletHolder addServlet(Class servlet,String pathSpec)
{
return getServletHandler().addServletWithMapping(servlet.getName(), pathSpec);
}
/* ------------------------------------------------------------ */
/** conveniance method to add a servlet.
*/
public void addServlet(ServletHolder servlet,String pathSpec)
{
getServletHandler().addServletWithMapping(servlet, pathSpec);
}
/* ------------------------------------------------------------ */
/** conveniance method to add a filter
*/
public void addFilter(FilterHolder holder,String pathSpec,EnumSet dispatches)
{
getServletHandler().addFilterWithMapping(holder,pathSpec,dispatches);
}
/* ------------------------------------------------------------ */
/** convenience method to add a filter
*/
public FilterHolder addFilter(Class filterClass,String pathSpec,EnumSet dispatches)
{
return getServletHandler().addFilterWithMapping(filterClass,pathSpec,dispatches);
}
/* ------------------------------------------------------------ */
/** convenience method to add a filter
*/
public FilterHolder addFilter(String filterClass,String pathSpec,EnumSet dispatches)
{
return getServletHandler().addFilterWithMapping(filterClass,pathSpec,dispatches);
}
/**
* notification that a ServletRegistration has been created so we can track the annotations
* @param holder new holder created through the api.
* @return the ServletRegistration.Dynamic
*/
protected ServletRegistration.Dynamic dynamicHolderAdded(ServletHolder holder) {
return holder.getRegistration();
}
/**
* delegate for ServletContext.declareRole method
* @param roleNames role names to add
*/
protected void addRoles(String... roleNames) {
//Get a reference to the SecurityHandler, which must be ConstraintAware
if (_securityHandler != null && _securityHandler instanceof ConstraintAware)
{
HashSet union = new HashSet();
Set existing = ((ConstraintAware)_securityHandler).getRoles();
if (existing != null)
union.addAll(existing);
union.addAll(Arrays.asList(roleNames));
((ConstraintSecurityHandler)_securityHandler).setRoles(union);
}
}
/**
* Delegate for ServletRegistration.Dynamic.setServletSecurity method
* @param registration ServletRegistration.Dynamic instance that setServletSecurity was called on
* @param servletSecurityElement new security info
* @return the set of exact URL mappings currently associated with the registration that are also present in the web.xml
* security constraints and thus will be unaffected by this call.
*/
public Set setServletSecurity(ServletRegistration.Dynamic registration, ServletSecurityElement servletSecurityElement)
{
//Default implementation is to just accept them all. If using a webapp, then this behaviour is overridden in WebAppContext.setServletSecurity
Collection pathSpecs = registration.getMappings();
if (pathSpecs != null)
{
for (String pathSpec:pathSpecs)
{
List mappings = ConstraintSecurityHandler.createConstraintsWithMappingsForPath(registration.getName(), pathSpec, servletSecurityElement);
for (ConstraintMapping m:mappings)
((ConstraintAware)getSecurityHandler()).addConstraintMapping(m);
}
}
return Collections.emptySet();
}
public void restrictEventListener (EventListener e)
{
if (_restrictListeners && e instanceof ServletContextListener)
_restrictedContextListeners = LazyList.add(_restrictedContextListeners, e);
}
public boolean isRestrictListeners() {
return _restrictListeners;
}
public void setRestrictListeners(boolean restrictListeners) {
this._restrictListeners = restrictListeners;
}
public void callContextInitialized(ServletContextListener l, ServletContextEvent e)
{
try
{
//toggle state of the dynamic API so that the listener cannot use it
if (LazyList.contains(_restrictedContextListeners, l))
this.getServletContext().setEnabled(false);
super.callContextInitialized(l, e);
}
finally
{
//untoggle the state of the dynamic API
this.getServletContext().setEnabled(true);
}
}
public void callContextDestroyed(ServletContextListener l, ServletContextEvent e)
{
super.callContextDestroyed(l, e);
}
/* ------------------------------------------------------------ */
/**
* @param sessionHandler The sessionHandler to set.
*/
public void setSessionHandler(SessionHandler sessionHandler)
{
if (isStarted())
throw new IllegalStateException("STARTED");
_sessionHandler = sessionHandler;
}
/* ------------------------------------------------------------ */
/**
* @param securityHandler The {@link SecurityHandler} to set on this context.
*/
public void setSecurityHandler(SecurityHandler securityHandler)
{
if (isStarted())
throw new IllegalStateException("STARTED");
_securityHandler = securityHandler;
}
/* ------------------------------------------------------------ */
/**
* @param servletHandler The servletHandler to set.
*/
public void setServletHandler(ServletHandler servletHandler)
{
if (isStarted())
throw new IllegalStateException("STARTED");
_servletHandler = servletHandler;
}
/* ------------------------------------------------------------ */
/**
* @return The decorator list used to resource inject new Filters, Servlets and EventListeners
*/
public List getDecorators()
{
return Collections.unmodifiableList(_decorators);
}
/* ------------------------------------------------------------ */
/**
* @param decorators The lis of {@link Decorator}s
*/
public void setDecorators(List decorators)
{
_decorators.clear();
_decorators.addAll(decorators);
}
/* ------------------------------------------------------------ */
/**
* @param decorator The decorator to add
*/
public void addDecorator(Decorator decorator)
{
_decorators.add(decorator);
}
/* ------------------------------------------------------------ */
void destroyServlet(Servlet servlet)
{
for (Decorator decorator : _decorators)
decorator.destroyServletInstance(servlet);
}
/* ------------------------------------------------------------ */
void destroyFilter(Filter filter)
{
for (Decorator decorator : _decorators)
decorator.destroyFilterInstance(filter);
}
/* ------------------------------------------------------------ */
public static class JspPropertyGroup implements JspPropertyGroupDescriptor
{
private List _urlPatterns = new ArrayList();
private String _elIgnored;
private String _pageEncoding;
private String _scriptingInvalid;
private String _isXml;
private List _includePreludes = new ArrayList();
private List _includeCodas = new ArrayList();
private String _deferredSyntaxAllowedAsLiteral;
private String _trimDirectiveWhitespaces;
private String _defaultContentType;
private String _buffer;
private String _errorOnUndeclaredNamespace;
/**
* @see javax.servlet.descriptor.JspPropertyGroupDescriptor#getUrlPatterns()
*/
public Collection getUrlPatterns()
{
return new ArrayList(_urlPatterns); // spec says must be a copy
}
public void addUrlPattern (String s)
{
if (!_urlPatterns.contains(s))
_urlPatterns.add(s);
}
/**
* @see javax.servlet.descriptor.JspPropertyGroupDescriptor#getElIgnored()
*/
public String getElIgnored()
{
return _elIgnored;
}
public void setElIgnored (String s)
{
_elIgnored = s;
}
/**
* @see javax.servlet.descriptor.JspPropertyGroupDescriptor#getPageEncoding()
*/
public String getPageEncoding()
{
return _pageEncoding;
}
public void setPageEncoding(String pageEncoding)
{
_pageEncoding = pageEncoding;
}
public void setScriptingInvalid(String scriptingInvalid)
{
_scriptingInvalid = scriptingInvalid;
}
public void setIsXml(String isXml)
{
_isXml = isXml;
}
public void setDeferredSyntaxAllowedAsLiteral(String deferredSyntaxAllowedAsLiteral)
{
_deferredSyntaxAllowedAsLiteral = deferredSyntaxAllowedAsLiteral;
}
public void setTrimDirectiveWhitespaces(String trimDirectiveWhitespaces)
{
_trimDirectiveWhitespaces = trimDirectiveWhitespaces;
}
public void setDefaultContentType(String defaultContentType)
{
_defaultContentType = defaultContentType;
}
public void setBuffer(String buffer)
{
_buffer = buffer;
}
public void setErrorOnUndeclaredNamespace(String errorOnUndeclaredNamespace)
{
_errorOnUndeclaredNamespace = errorOnUndeclaredNamespace;
}
/**
* @see javax.servlet.descriptor.JspPropertyGroupDescriptor#getScriptingInvalid()
*/
public String getScriptingInvalid()
{
return _scriptingInvalid;
}
/**
* @see javax.servlet.descriptor.JspPropertyGroupDescriptor#getIsXml()
*/
public String getIsXml()
{
return _isXml;
}
/**
* @see javax.servlet.descriptor.JspPropertyGroupDescriptor#getIncludePreludes()
*/
public Collection getIncludePreludes()
{
return new ArrayList(_includePreludes); //must be a copy
}
public void addIncludePrelude(String prelude)
{
if (!_includePreludes.contains(prelude))
_includePreludes.add(prelude);
}
/**
* @see javax.servlet.descriptor.JspPropertyGroupDescriptor#getIncludeCodas()
*/
public Collection getIncludeCodas()
{
return new ArrayList(_includeCodas); //must be a copy
}
public void addIncludeCoda (String coda)
{
if (!_includeCodas.contains(coda))
_includeCodas.add(coda);
}
/**
* @see javax.servlet.descriptor.JspPropertyGroupDescriptor#getDeferredSyntaxAllowedAsLiteral()
*/
public String getDeferredSyntaxAllowedAsLiteral()
{
return _deferredSyntaxAllowedAsLiteral;
}
/**
* @see javax.servlet.descriptor.JspPropertyGroupDescriptor#getTrimDirectiveWhitespaces()
*/
public String getTrimDirectiveWhitespaces()
{
return _trimDirectiveWhitespaces;
}
/**
* @see javax.servlet.descriptor.JspPropertyGroupDescriptor#getDefaultContentType()
*/
public String getDefaultContentType()
{
return _defaultContentType;
}
/**
* @see javax.servlet.descriptor.JspPropertyGroupDescriptor#getBuffer()
*/
public String getBuffer()
{
return _buffer;
}
/**
* @see javax.servlet.descriptor.JspPropertyGroupDescriptor#getErrorOnUndeclaredNamespace()
*/
public String getErrorOnUndeclaredNamespace()
{
return _errorOnUndeclaredNamespace;
}
public String toString ()
{
StringBuffer sb = new StringBuffer();
sb.append("JspPropertyGroupDescriptor:");
sb.append(" el-ignored="+_elIgnored);
sb.append(" is-xml="+_isXml);
sb.append(" page-encoding="+_pageEncoding);
sb.append(" scripting-invalid="+_scriptingInvalid);
sb.append(" deferred-syntax-allowed-as-literal="+_deferredSyntaxAllowedAsLiteral);
sb.append(" trim-directive-whitespaces"+_trimDirectiveWhitespaces);
sb.append(" default-content-type="+_defaultContentType);
sb.append(" buffer="+_buffer);
sb.append(" error-on-undeclared-namespace="+_errorOnUndeclaredNamespace);
for (String prelude:_includePreludes)
sb.append(" include-prelude="+prelude);
for (String coda:_includeCodas)
sb.append(" include-coda="+coda);
return sb.toString();
}
}
/* ------------------------------------------------------------ */
public static class TagLib implements TaglibDescriptor
{
private String _uri;
private String _location;
/**
* @see javax.servlet.descriptor.TaglibDescriptor#getTaglibURI()
*/
public String getTaglibURI()
{
return _uri;
}
public void setTaglibURI(String uri)
{
_uri = uri;
}
/**
* @see javax.servlet.descriptor.TaglibDescriptor#getTaglibLocation()
*/
public String getTaglibLocation()
{
return _location;
}
public void setTaglibLocation(String location)
{
_location = location;
}
public String toString()
{
return ("TagLibDescriptor: taglib-uri="+_uri+" location="+_location);
}
}
/* ------------------------------------------------------------ */
public static class JspConfig implements JspConfigDescriptor
{
private List _taglibs = new ArrayList();
private List _jspPropertyGroups = new ArrayList();
public JspConfig() {}
/**
* @see javax.servlet.descriptor.JspConfigDescriptor#getTaglibs()
*/
public Collection getTaglibs()
{
return new ArrayList(_taglibs);
}
public void addTaglibDescriptor (TaglibDescriptor d)
{
_taglibs.add(d);
}
/**
* @see javax.servlet.descriptor.JspConfigDescriptor#getJspPropertyGroups()
*/
public Collection getJspPropertyGroups()
{
return new ArrayList(_jspPropertyGroups);
}
public void addJspPropertyGroup(JspPropertyGroupDescriptor g)
{
_jspPropertyGroups.add(g);
}
public String toString()
{
StringBuffer sb = new StringBuffer();
sb.append("JspConfigDescriptor: \n");
for (TaglibDescriptor taglib:_taglibs)
sb.append(taglib+"\n");
for (JspPropertyGroupDescriptor jpg:_jspPropertyGroups)
sb.append(jpg+"\n");
return sb.toString();
}
}
/* ------------------------------------------------------------ */
public class Context extends ContextHandler.Context
{
/* ------------------------------------------------------------ */
/*
* @see javax.servlet.ServletContext#getNamedDispatcher(java.lang.String)
*/
@Override
public RequestDispatcher getNamedDispatcher(String name)
{
ContextHandler context=org.eclipse.jetty.servlet.ServletContextHandler.this;
if (_servletHandler==null)
return null;
ServletHolder holder = _servletHandler.getServlet(name);
if (holder==null || !holder.isEnabled())
return null;
return new Dispatcher(context, name);
}
/* ------------------------------------------------------------ */
/**
* @since servlet-api-3.0
*/
@Override
public FilterRegistration.Dynamic addFilter(String filterName, Class filterClass)
{
if (isStarted())
throw new IllegalStateException();
if (!_enabled)
throw new UnsupportedOperationException();
final ServletHandler handler = ServletContextHandler.this.getServletHandler();
FilterHolder holder = handler.getFilter(filterName);
if (holder == null)
{
//new filter
holder = handler.newFilterHolder(Holder.Source.JAVAX_API);
holder.setName(filterName);
holder.setHeldClass(filterClass);
handler.addFilter(holder);
return holder.getRegistration();
}
if (holder.getClassName()==null && holder.getHeldClass()==null)
{
//preliminary filter registration completion
holder.setHeldClass(filterClass);
return holder.getRegistration();
}
else
return null; //existing filter
}
/* ------------------------------------------------------------ */
/**
* @since servlet-api-3.0
*/
@Override
public FilterRegistration.Dynamic addFilter(String filterName, String className)
{
if (isStarted())
throw new IllegalStateException();
if (!_enabled)
throw new UnsupportedOperationException();
final ServletHandler handler = ServletContextHandler.this.getServletHandler();
FilterHolder holder = handler.getFilter(filterName);
if (holder == null)
{
//new filter
holder = handler.newFilterHolder(Holder.Source.JAVAX_API);
holder.setName(filterName);
holder.setClassName(className);
handler.addFilter(holder);
return holder.getRegistration();
}
if (holder.getClassName()==null && holder.getHeldClass()==null)
{
//preliminary filter registration completion
holder.setClassName(className);
return holder.getRegistration();
}
else
return null; //existing filter
}
/* ------------------------------------------------------------ */
/**
* @since servlet-api-3.0
*/
@Override
public FilterRegistration.Dynamic addFilter(String filterName, Filter filter)
{
if (isStarted())
throw new IllegalStateException();
if (!_enabled)
throw new UnsupportedOperationException();
final ServletHandler handler = ServletContextHandler.this.getServletHandler();
FilterHolder holder = handler.getFilter(filterName);
if (holder == null)
{
//new filter
holder = handler.newFilterHolder(Holder.Source.JAVAX_API);
holder.setName(filterName);
holder.setFilter(filter);
handler.addFilter(holder);
return holder.getRegistration();
}
if (holder.getClassName()==null && holder.getHeldClass()==null)
{
//preliminary filter registration completion
holder.setFilter(filter);
return holder.getRegistration();
}
else
return null; //existing filter
}
/* ------------------------------------------------------------ */
/**
* @since servlet-api-3.0
*/
@Override
public ServletRegistration.Dynamic addServlet(String servletName, Class servletClass)
{
if (!isStarting())
throw new IllegalStateException();
if (!_enabled)
throw new UnsupportedOperationException();
final ServletHandler handler = ServletContextHandler.this.getServletHandler();
ServletHolder holder = handler.getServlet(servletName);
if (holder == null)
{
//new servlet
holder = handler.newServletHolder(Holder.Source.JAVAX_API);
holder.setName(servletName);
holder.setHeldClass(servletClass);
handler.addServlet(holder);
return dynamicHolderAdded(holder);
}
//complete a partial registration
if (holder.getClassName()==null && holder.getHeldClass()==null)
{
holder.setHeldClass(servletClass);
return holder.getRegistration();
}
else
return null; //existing completed registration for servlet name
}
/* ------------------------------------------------------------ */
/**
* @since servlet-api-3.0
*/
@Override
public ServletRegistration.Dynamic addServlet(String servletName, String className)
{
if (!isStarting())
throw new IllegalStateException();
if (!_enabled)
throw new UnsupportedOperationException();
final ServletHandler handler = ServletContextHandler.this.getServletHandler();
ServletHolder holder = handler.getServlet(servletName);
if (holder == null)
{
//new servlet
holder = handler.newServletHolder(Holder.Source.JAVAX_API);
holder.setName(servletName);
holder.setClassName(className);
handler.addServlet(holder);
return dynamicHolderAdded(holder);
}
//complete a partial registration
if (holder.getClassName()==null && holder.getHeldClass()==null)
{
holder.setClassName(className);
return holder.getRegistration();
}
else
return null; //existing completed registration for servlet name
}
/* ------------------------------------------------------------ */
/**
* @since servlet-api-3.0
*/
@Override
public ServletRegistration.Dynamic addServlet(String servletName, Servlet servlet)
{
if (!isStarting())
throw new IllegalStateException();
if (!_enabled)
throw new UnsupportedOperationException();
//TODO handle partial registrations
final ServletHandler handler = ServletContextHandler.this.getServletHandler();
ServletHolder holder = handler.getServlet(servletName);
if (holder == null)
{
holder = handler.newServletHolder(Holder.Source.JAVAX_API);
holder.setName(servletName);
holder.setServlet(servlet);
handler.addServlet(holder);
return dynamicHolderAdded(holder);
}
//complete a partial registration
if (holder.getClassName()==null && holder.getHeldClass()==null)
{
holder.setServlet(servlet);
return holder.getRegistration();
}
else
return null; //existing completed registration for servlet name
}
/* ------------------------------------------------------------ */
@Override
public boolean setInitParameter(String name, String value)
{
// TODO other started conditions
if (!isStarting())
throw new IllegalStateException();
if (!_enabled)
throw new UnsupportedOperationException();
return super.setInitParameter(name,value);
}
/* ------------------------------------------------------------ */
@Override
public T createFilter(Class c) throws ServletException
{
try
{
T f = c.newInstance();
for (int i=_decorators.size()-1; i>=0; i--)
{
Decorator decorator = _decorators.get(i);
f=decorator.decorateFilterInstance(f);
}
return f;
}
catch (InstantiationException e)
{
throw new ServletException(e);
}
catch (IllegalAccessException e)
{
throw new ServletException(e);
}
}
/* ------------------------------------------------------------ */
@Override
public T createServlet(Class c) throws ServletException
{
try
{
T s = c.newInstance();
for (int i=_decorators.size()-1; i>=0; i--)
{
Decorator decorator = _decorators.get(i);
s=decorator.decorateServletInstance(s);
}
return s;
}
catch (InstantiationException e)
{
throw new ServletException(e);
}
catch (IllegalAccessException e)
{
throw new ServletException(e);
}
}
@Override
public Set getDefaultSessionTrackingModes()
{
if (_sessionHandler!=null)
return _sessionHandler.getSessionManager().getDefaultSessionTrackingModes();
return null;
}
@Override
public Set getEffectiveSessionTrackingModes()
{
if (_sessionHandler!=null)
return _sessionHandler.getSessionManager().getEffectiveSessionTrackingModes();
return null;
}
@Override
public FilterRegistration getFilterRegistration(String filterName)
{
if (!_enabled)
throw new UnsupportedOperationException();
final FilterHolder holder=ServletContextHandler.this.getServletHandler().getFilter(filterName);
return (holder==null)?null:holder.getRegistration();
}
@Override
public Map getFilterRegistrations()
{
if (!_enabled)
throw new UnsupportedOperationException();
HashMap registrations = new HashMap();
ServletHandler handler=ServletContextHandler.this.getServletHandler();
FilterHolder[] holders=handler.getFilters();
if (holders!=null)
{
for (FilterHolder holder : holders)
registrations.put(holder.getName(),holder.getRegistration());
}
return registrations;
}
@Override
public ServletRegistration getServletRegistration(String servletName)
{
if (!_enabled)
throw new UnsupportedOperationException();
final ServletHolder holder=ServletContextHandler.this.getServletHandler().getServlet(servletName);
return (holder==null)?null:holder.getRegistration();
}
@Override
public Map getServletRegistrations()
{
if (!_enabled)
throw new UnsupportedOperationException();
HashMap registrations = new HashMap();
ServletHandler handler=ServletContextHandler.this.getServletHandler();
ServletHolder[] holders=handler.getServlets();
if (holders!=null)
{
for (ServletHolder holder : holders)
registrations.put(holder.getName(),holder.getRegistration());
}
return registrations;
}
@Override
public SessionCookieConfig getSessionCookieConfig()
{
// TODO other started conditions
if (!_enabled)
throw new UnsupportedOperationException();
if (_sessionHandler!=null)
return _sessionHandler.getSessionManager().getSessionCookieConfig();
return null;
}
@Override
public void setSessionTrackingModes(Set sessionTrackingModes)
{
// TODO other started conditions
if (!isStarting())
throw new IllegalStateException();
if (!_enabled)
throw new UnsupportedOperationException();
if (_sessionHandler!=null)
_sessionHandler.getSessionManager().setSessionTrackingModes(sessionTrackingModes);
}
@Override
public void addListener(String className)
{
// TODO other started conditions
if (!isStarting())
throw new IllegalStateException();
if (!_enabled)
throw new UnsupportedOperationException();
super.addListener(className);
}
@Override
public void addListener(T t)
{
// TODO other started conditions
if (!isStarting())
throw new IllegalStateException();
if (!_enabled)
throw new UnsupportedOperationException();
super.addListener(t);
}
@Override
public void addListener(Class listenerClass)
{
// TODO other started conditions
if (!isStarting())
throw new IllegalStateException();
if (!_enabled)
throw new UnsupportedOperationException();
super.addListener(listenerClass);
}
@Override
public T createListener(Class clazz) throws ServletException
{
try
{
T l = super.createListener(clazz);
for (int i=_decorators.size()-1; i>=0; i--)
{
Decorator decorator = _decorators.get(i);
l=decorator.decorateListenerInstance(l);
}
return l;
}
catch(ServletException e)
{
throw e;
}
catch(Exception e)
{
throw new ServletException(e);
}
}
@Override
public JspConfigDescriptor getJspConfigDescriptor()
{
return _jspConfig;
}
@Override
public void setJspConfigDescriptor(JspConfigDescriptor d)
{
_jspConfig = d;
}
@Override
public void declareRoles(String... roleNames)
{
if (!isStarting())
throw new IllegalStateException();
if (!_enabled)
throw new UnsupportedOperationException();
addRoles(roleNames);
}
}
/* ------------------------------------------------------------ */
/** Interface to decorate loaded classes.
*/
public interface Decorator
{
T decorateFilterInstance(T filter) throws ServletException;
T decorateServletInstance(T servlet) throws ServletException;
T decorateListenerInstance(T listener) throws ServletException;
void decorateFilterHolder(FilterHolder filter) throws ServletException;
void decorateServletHolder(ServletHolder servlet) throws ServletException;
void destroyServletInstance(Servlet s);
void destroyFilterInstance(Filter f);
void destroyListenerInstance(EventListener f);
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy