Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
// ========================================================================
// $Id: WebApplicationContext.java,v 1.136 2005/10/26 08:11:04 gregwilkins Exp $
// Copyright 2000-2004 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// Licensed 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.openqa.jetty.jetty.servlet;
import java.io.Externalizable;
import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.security.PermissionCollection;
import java.util.Collections;
import java.util.EventListener;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import org.apache.commons.logging.Log;
import org.openqa.jetty.log.LogFactory;
import org.openqa.jetty.http.HttpException;
import org.openqa.jetty.http.HttpHandler;
import org.openqa.jetty.http.HttpRequest;
import org.openqa.jetty.http.HttpResponse;
import org.openqa.jetty.http.UserRealm;
import org.openqa.jetty.jetty.Server;
import org.openqa.jetty.util.JarResource;
import org.openqa.jetty.util.LazyList;
import org.openqa.jetty.util.Loader;
import org.openqa.jetty.util.MultiException;
import org.openqa.jetty.util.Resource;
/* ------------------------------------------------------------ */
/** Standard web.xml configured HttpContext.
*
* This specialization of HttpContext uses the standardized web.xml
* to describe a web application and configure the handlers for the
* HttpContext.
*
* If a file named web-jetty.xml or jetty-web.xml is found in the
* WEB-INF directory it is applied to the context using the
* XmlConfiguration format.
*
* A single WebApplicationHandler instance is used to provide
* security, filter, sevlet and resource handling.
*
* @see org.openqa.jetty.jetty.servlet.WebApplicationHandler
* @version $Id: WebApplicationContext.java,v 1.136 2005/10/26 08:11:04 gregwilkins Exp $
* @author Greg Wilkins (gregw)
*/
public class WebApplicationContext extends ServletHttpContext implements Externalizable
{
private static Log log= LogFactory.getLog(WebApplicationContext.class);
/* ------------------------------------------------------------ */
private String _defaultsDescriptor= "org/openqa/jetty/jetty/servlet/webdefault.xml";
private String _war;
private boolean _extract;
private boolean _ignorewebjetty;
private boolean _distributable;
private Configuration[] _configurations;
private String[] _configurationClassNames;
private transient Map _resourceAliases;
private transient Resource _webApp;
private transient Resource _webInf;
private transient WebApplicationHandler _webAppHandler;
private transient Object _contextListeners;
private transient Map _errorPages;
/* ------------------------------------------------------------ */
/** Constructor.
*/
public WebApplicationContext()
{
}
/* ------------------------------------------------------------ */
/** Constructor.
* @param webApp The Web application directory or WAR file.
*/
public WebApplicationContext(String webApp)
{
_war= webApp;
}
/* ------------------------------------------------------------ */
public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException
{
out.writeObject(getContextPath());
out.writeObject(getVirtualHosts());
HttpHandler[] handlers= getHandlers();
for (int i= 0; i < handlers.length; i++)
{
if (handlers[i] instanceof WebApplicationHandler)
break;
out.writeObject(handlers[i]);
}
out.writeObject(getAttributes());
out.writeBoolean(isRedirectNullPath());
out.writeInt(getMaxCachedFileSize());
out.writeInt(getMaxCacheSize());
out.writeBoolean(getStatsOn());
out.writeObject(getPermissions());
out.writeBoolean(isClassLoaderJava2Compliant());
out.writeObject(_defaultsDescriptor);
out.writeObject(_war);
out.writeBoolean(_extract);
out.writeBoolean(_ignorewebjetty);
out.writeBoolean(_distributable);
out.writeObject(_configurationClassNames);
}
/* ------------------------------------------------------------ */
public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException
{
setContextPath((String)in.readObject());
setVirtualHosts((String[])in.readObject());
Object o= in.readObject();
while (o instanceof HttpHandler)
{
addHandler((HttpHandler)o);
o= in.readObject();
}
setAttributes((Map)o);
setRedirectNullPath(in.readBoolean());
setMaxCachedFileSize(in.readInt());
setMaxCacheSize(in.readInt());
setStatsOn(in.readBoolean());
setPermissions((PermissionCollection)in.readObject());
setClassLoaderJava2Compliant(in.readBoolean());
_defaultsDescriptor= (String)in.readObject();
_war= (String)in.readObject();
_extract= in.readBoolean();
_ignorewebjetty= in.readBoolean();
_distributable= in.readBoolean();
_configurationClassNames=(String[])in.readObject();
}
/* ------------------------------------------------------------ */
public void setConfigurationClassNames (String[] configurationClassNames)
{
if (null != configurationClassNames)
{
_configurationClassNames = new String[configurationClassNames.length];
System.arraycopy (configurationClassNames, 0, _configurationClassNames, 0, configurationClassNames.length);
}
}
/* ------------------------------------------------------------ */
public String[] getConfigurationClassNames ()
{
return _configurationClassNames;
}
/* ------------------------------------------------------------ */
/**
* @param war Filename or URL of the web application directory or WAR file.
*/
public void setWAR(String war)
{
_war= war;
}
/* ------------------------------------------------------------ */
public String getWAR()
{
return _war;
}
/* ------------------------------------------------------------ */
public WebApplicationHandler getWebApplicationHandler()
{
if (_webAppHandler == null)
getServletHandler();
return _webAppHandler;
}
/* ------------------------------------------------------------ */
private void resolveWebApp() throws IOException
{
if (_webApp == null && _war != null && _war.length() > 0)
{
// Set dir or WAR
_webApp= Resource.newResource(_war);
// Accept aliases for WAR files
if (_webApp.getAlias() != null)
{
log.info(_webApp + " anti-aliased to " + _webApp.getAlias());
_webApp= Resource.newResource(_webApp.getAlias());
}
if (log.isDebugEnabled())
log.debug(
"Try webapp=" + _webApp + ", exists=" + _webApp.exists() + ", directory=" + _webApp.isDirectory());
// Is the WAR usable directly?
if (_webApp.exists() && !_webApp.isDirectory() && !_webApp.toString().startsWith("jar:"))
{
// No - then lets see if it can be turned into a jar URL.
Resource jarWebApp= Resource.newResource("jar:" + _webApp + "!/");
if (jarWebApp.exists() && jarWebApp.isDirectory())
{
_webApp= jarWebApp;
_war= _webApp.toString();
if (log.isDebugEnabled())
log.debug(
"Try webapp="
+ _webApp
+ ", exists="
+ _webApp.exists()
+ ", directory="
+ _webApp.isDirectory());
}
}
// If we should extract or the URL is still not usable
if (_webApp.exists()
&& (!_webApp.isDirectory()
|| (_extract && _webApp.getFile() == null)
|| (_extract && _webApp.getFile() != null && !_webApp.getFile().isDirectory())))
{
// Then extract it.
File tempDir= new File(getTempDirectory(), "webapp");
if (tempDir.exists())
tempDir.delete();
tempDir.mkdir();
tempDir.deleteOnExit();
log.info("Extract " + _war + " to " + tempDir);
JarResource.extract(_webApp, tempDir, true);
_webApp= Resource.newResource(tempDir.getCanonicalPath());
if (log.isDebugEnabled())
log.debug(
"Try webapp="
+ _webApp
+ ", exists="
+ _webApp.exists()
+ ", directory="
+ _webApp.isDirectory());
}
// Now do we have something usable?
if (!_webApp.exists() || !_webApp.isDirectory())
{
log.warn("Web application not found " + _war);
throw new java.io.FileNotFoundException(_war);
}
if (log.isDebugEnabled())
log.debug("webapp=" + _webApp);
// Iw there a WEB-INF directory?
_webInf= _webApp.addPath("WEB-INF/");
if (!_webInf.exists() || !_webInf.isDirectory())
_webInf= null;
else
{
// Is there a WEB-INF work directory
Resource work= _webInf.addPath("work");
if (work.exists()
&& work.isDirectory()
&& work.getFile() != null
&& work.getFile().canWrite()
&& getAttribute("javax.servlet.context.tempdir") == null)
setAttribute("javax.servlet.context.tempdir", work.getFile());
}
// ResourcePath
super.setBaseResource(_webApp);
}
}
/* ------------------------------------------------------------ */
public Resource getWebInf() throws IOException
{
if (_webInf==null)
resolveWebApp();
return _webInf;
}
/* ------------------------------------------------------------ */
/** Get the context ServletHandler.
* Conveniance method. If no ServletHandler exists, a new one is added to
* the context. This derivation of the method creates a
* WebApplicationHandler extension of ServletHandler.
* @return WebApplicationHandler
*/
public synchronized ServletHandler getServletHandler()
{
if (_webAppHandler == null)
{
_webAppHandler= (WebApplicationHandler)getHandler(WebApplicationHandler.class);
if (_webAppHandler == null)
{
if (getHandler(ServletHandler.class) != null)
throw new IllegalStateException("Cannot have ServletHandler in WebApplicationContext");
_webAppHandler= new WebApplicationHandler();
addHandler(_webAppHandler);
}
}
return _webAppHandler;
}
/* ------------------------------------------------------------ */
public void setPermissions(PermissionCollection permissions)
{
if (!_ignorewebjetty)
log.warn("Permissions set with web-jetty.xml enabled");
super.setPermissions(permissions);
}
/* ------------------------------------------------------------ */
public boolean isIgnoreWebJetty()
{
return _ignorewebjetty;
}
/* ------------------------------------------------------------ */
/**
* @param b If TRUE, web-jetty.xml and jetty-web.xml configuration
* files are ignored.
*/
public void setIgnoreWebJetty(boolean b)
{
_ignorewebjetty= b;
if (b && getPermissions() != null)
log.warn("Permissions set with web-jetty.xml enabled");
}
/* ------------------------------------------------------------ */
public boolean isDistributable()
{
return _distributable;
}
/* ------------------------------------------------------------ */
public void setDistributable(boolean distributable)
{
_distributable=distributable;
}
/* ------------------------------------------------------------ */
public Configuration[] getConfigurations ()
{
return _configurations;
}
/* ------------------------------------------------------------ */
protected Configuration[] loadConfigurations() throws Exception
{
String[] names = _configurationClassNames;
//if this webapp does not have its own set of configurators, use the defaults
if (null==names)
names = ((Server)getHttpServer()).getWebApplicationConfigurationClassNames();
if (null!=names)
{
//instantiate instances for each
Object[] nullArgs = new Object[0];
Configuration[] configurations = new Configuration[names.length];
for (int i=0; i< names.length; i++)
{
configurations[i] =
(Configuration)Loader.loadClass(WebApplicationContext.class, names[i]).getConstructors()[0].newInstance(nullArgs);
if (log.isDebugEnabled()){log.debug("Loaded instance of "+names[i]);};
}
return configurations;
}
else
return new Configuration[0];
}
/* ------------------------------------------------------------ */
protected void configureClassPath() throws Exception
{
//call each of the instances
// first, configure the classpaths
for (int i=0; i<_configurations.length;i++)
{
_configurations[i].setWebApplicationContext(this);
_configurations[i].configureClassPath();
}
}
/* ------------------------------------------------------------ */
protected void configureDefaults() throws Exception
{
//next, configure default settings
for (int i=0;i<_configurations.length;i++)
{
_configurations[i].setWebApplicationContext(this);
_configurations[i].configureDefaults();
}
}
/* ------------------------------------------------------------ */
protected void configureWebApp () throws Exception
{
//finally, finish configuring the webapp
for (int i=0;i<_configurations.length;i++)
{
_configurations[i].setWebApplicationContext(this);
_configurations[i].configureWebApp();
}
}
/* ------------------------------------------------------------ */
/** Start the Web Application.
* @exception IOException
*/
protected void doStart() throws Exception
{
if (isStarted())
return;
// save context classloader
Thread thread= Thread.currentThread();
ClassLoader lastContextLoader= thread.getContextClassLoader();
MultiException mex= null;
try
{
// Find the webapp
resolveWebApp();
// Get the handler
getServletHandler();
_configurations=loadConfigurations();
// initialize the classloader
configureClassPath();
initClassLoader(true);
thread.setContextClassLoader(getClassLoader());
initialize();
// Do the default configuration
configureDefaults();
// Set classpath for Jasper.
Map.Entry entry= _webAppHandler.getHolderEntry("test.jsp");
if (entry != null)
{
ServletHolder jspHolder= (ServletHolder)entry.getValue();
if (jspHolder != null && jspHolder.getInitParameter("classpath") == null)
{
String fileClassPath= getFileClassPath();
jspHolder.setInitParameter("classpath", fileClassPath);
if (log.isDebugEnabled())
log.debug("Set classpath=" + fileClassPath + " for " + jspHolder);
}
}
// configure webapp
configureWebApp();
// If we have servlets, don't init them yet
_webAppHandler.setAutoInitializeServlets(false);
// Start handlers
super.doStart();
mex= new MultiException();
// Context listeners
if (_contextListeners != null && _webAppHandler != null)
{
ServletContextEvent event= new ServletContextEvent(getServletContext());
for (int i= 0; i < LazyList.size(_contextListeners); i++)
{
try
{
((ServletContextListener)LazyList.get(_contextListeners, i)).contextInitialized(event);
}
catch (Exception ex)
{
mex.add(ex);
}
}
}
// OK to Initialize servlets now
if (_webAppHandler != null && _webAppHandler.isStarted())
{
try
{
_webAppHandler.initializeServlets();
}
catch (Exception ex)
{
mex.add(ex);
}
}
}
catch (Exception e)
{
log.warn("Configuration error on " + _war, e);
throw e;
}
finally
{
thread.setContextClassLoader(lastContextLoader);
}
if (mex != null)
mex.ifExceptionThrow();
}
/* ------------------------------------------------------------ */
/** Stop the web application.
* Handlers for resource, servlet, filter and security are removed
* as they are recreated and configured by any subsequent call to start().
* @exception InterruptedException
*/
protected void doStop() throws Exception
{
MultiException mex=new MultiException();
Thread thread= Thread.currentThread();
ClassLoader lastContextLoader= thread.getContextClassLoader();
try
{
// Context listeners
if (_contextListeners != null)
{
if (_webAppHandler != null)
{
ServletContextEvent event= new ServletContextEvent(getServletContext());
for (int i= LazyList.size(_contextListeners); i-- > 0;)
{
try
{
((ServletContextListener)LazyList.get(_contextListeners, i)).contextDestroyed(event);
}
catch (Exception e)
{
mex.add(e);
}
}
}
}
_contextListeners= null;
// Stop the context
try
{
super.doStop();
}
catch (Exception e)
{
mex.add(e);
}
// clean up
clearSecurityConstraints();
if (_webAppHandler != null)
removeHandler(_webAppHandler);
_webAppHandler= null;
if (_errorPages != null)
_errorPages.clear();
_errorPages= null;
_webApp=null;
_webInf=null;
_configurations=null;
}
finally
{
thread.setContextClassLoader(lastContextLoader);
}
if (mex!=null)
mex.ifExceptionThrow();
}
/* ------------------------------------------------------------ */
public void destroy()
{
super.destroy();
if (isStarted())
throw new IllegalStateException();
_defaultsDescriptor=null;
_war=null;
_configurationClassNames=null;
if (_resourceAliases!=null)
_resourceAliases.clear();
_resourceAliases=null;
_contextListeners=null;
if (_errorPages!=null)
_errorPages.clear();
_errorPages=null;
}
/* ------------------------------------------------------------ */
public void handle(String pathInContext, String pathParams, HttpRequest httpRequest, HttpResponse httpResponse)
throws HttpException, IOException
{
if (!isStarted())
return;
try
{
super.handle(pathInContext, pathParams, httpRequest, httpResponse);
}
finally
{
if (!httpRequest.isHandled())
httpResponse.sendError(HttpResponse.__404_Not_Found);
httpRequest.setHandled(true);
if (!httpResponse.isCommitted())
{
httpResponse.completing();
httpResponse.commit();
}
}
}
/* ------------------------------------------------------------ */
public synchronized void addEventListener(EventListener listener) throws IllegalArgumentException
{
if (listener instanceof ServletContextListener)
{
_contextListeners= LazyList.add(_contextListeners, listener);
}
super.addEventListener(listener);
}
/* ------------------------------------------------------------ */
public synchronized void removeEventListener(EventListener listener)
{
_contextListeners= LazyList.remove(_contextListeners, listener);
super.removeEventListener(listener);
}
/* ------------------------------------------------------------ */
public String getDisplayName()
{
return getHttpContextName();
}
/* ------------------------------------------------------------ */
public void setDisplayName(String name)
{
setHttpContextName(name);
}
/* ------------------------------------------------------------ */
/** Set the defaults web.xml file.
* The default web.xml is used to configure all webapplications
* before the WEB-INF/web.xml file is applied. By default the
* org/mortbay/jetty/servlet/webdefault.xml resource from the
* org.openqa.jetty.jetty.jar is used.
* @param defaults File, Resource, URL or null.
*/
public void setDefaultsDescriptor(String defaults)
{
_defaultsDescriptor= defaults;
}
/* ------------------------------------------------------------ */
public String getDefaultsDescriptor()
{
return _defaultsDescriptor;
}
/* ------------------------------------------------------------ */
/**
* @param extract If true, a WAR is extracted to a temporary
* directory before being deployed.
*/
public void setExtractWAR(boolean extract)
{
_extract= extract;
}
/* ------------------------------------------------------------ */
public boolean getExtractWAR()
{
return _extract;
}
/* ------------------------------------------------------------ */
/**
* Initialize is called by the start method after the contexts classloader
* has been initialied, but before the defaults descriptor has been applied.
* The default implementation does nothing.
*
* @exception Exception if an error occurs
*/
protected void initialize() throws Exception
{
}
/* ------------------------------------------------------------ */
protected UserRealm getUserRealm(String name)
{
return getHttpServer().getRealm(name);
}
/* ------------------------------------------------------------ */
public String toString()
{
String name = getDisplayName();
return "WebApplicationContext[" + getContextPath() + "," + (name == null ? _war : name) + "]";
}
/* ------------------------------------------------------------ */
/** Set Resource Alias.
* Resource aliases map resource uri's within a context.
* They may optionally be used by a handler when looking for
* a resource.
* @param alias
* @param uri
*/
public void setResourceAlias(String alias, String uri)
{
if (_resourceAliases == null)
_resourceAliases= new HashMap(5);
_resourceAliases.put(alias, uri);
}
/* ------------------------------------------------------------ */
public Map getResourceAliases()
{
if (_resourceAliases == null)
return null;
return Collections.unmodifiableMap(_resourceAliases);
}
/* ------------------------------------------------------------ */
public String getResourceAlias(String alias)
{
if (_resourceAliases == null)
return null;
return (String)_resourceAliases.get(alias);
}
/* ------------------------------------------------------------ */
public String removeResourceAlias(String alias)
{
if (_resourceAliases == null)
return null;
return (String)_resourceAliases.remove(alias);
}
/* ------------------------------------------------------------ */
public Resource getResource(String uriInContext) throws IOException
{
IOException ioe= null;
Resource resource= null;
try
{
resource= super.getResource(uriInContext);
if (resource != null && resource.exists())
return resource;
}
catch (IOException e)
{
ioe= e;
}
String aliasedUri= getResourceAlias(uriInContext);
if (aliasedUri != null)
return super.getResource(aliasedUri);
if (ioe != null)
throw ioe;
return resource;
}
/* ------------------------------------------------------------ */
/** set error page URI.
* @param error A string representing an error code or a
* exception classname
* @param uriInContext
*/
public void setErrorPage(String error, String uriInContext)
{
if (_errorPages == null)
_errorPages= new HashMap();
_errorPages.put(error, uriInContext);
}
/* ------------------------------------------------------------ */
/** get error page URI.
* @param error A string representing an error code or a
* exception classname
* @return URI within context
*/
public String getErrorPage(String error)
{
if (_errorPages == null)
return null;
return (String)_errorPages.get(error);
}
/* ------------------------------------------------------------ */
public String removeErrorPage(String error)
{
if (_errorPages == null)
return null;
return (String)_errorPages.remove(error);
}
/* ------------------------------------------------------------------------------- */
/** Base Class for WebApplicationContext Configuration.
* This class can be extended to customize or extend the configuration
* of the WebApplicationContext. If WebApplicationContext.setConfiguration is not
* called, then an XMLConfiguration instance is created.
*
* @version $Revision: 1.136 $
* @author gregw
*/
public static interface Configuration extends Serializable
{
/* ------------------------------------------------------------------------------- */
/** Set up a context on which to perform the configuration.
* @param context
*/
public void setWebApplicationContext (WebApplicationContext context);
/* ------------------------------------------------------------------------------- */
/** Get the context on which the configuration is performed.
* @return A WebApplicationContext object.
*/
public WebApplicationContext getWebApplicationContext ();
/* ------------------------------------------------------------------------------- */
/** Configure ClassPath.
* This method is called before the context ClassLoader is created.
* Paths and libraries should be added to the context using the setClassPath,
* addClassPath and addClassPaths methods. The default implementation looks
* for WEB-INF/classes, WEB-INF/lib/*.zip and WEB-INF/lib/*.jar
* @throws Exception
*/
public void configureClassPath()
throws Exception;
/* ------------------------------------------------------------------------------- */
/** Configure Defaults.
* This method is called to intialize the context to the containers default configuration.
* Typically this would mean application of the webdefault.xml file. The default
* implementation does nothing.
* @throws Exception
*/
public void configureDefaults()
throws Exception;
/* ------------------------------------------------------------------------------- */
/** Configure WebApp.
* This method is called to apply the standard and vendor deployment descriptors.
* Typically this is web.xml and jetty-web.xml. The default implementation does nothing.
* @throws Exception
*/
public void configureWebApp()
throws Exception;
}
}
