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.
/*
* 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.jasper.compiler;
import static org.apache.jasper.JasperMessages.MESSAGES;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FilePermission;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLDecoder;
import java.security.CodeSource;
import java.security.Permission;
import java.security.PermissionCollection;
import java.security.Policy;
import java.security.cert.Certificate;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import javax.servlet.ServletContext;
import javax.servlet.jsp.JspFactory;
import org.apache.jasper.Constants;
import org.apache.jasper.JasperLogger;
import org.apache.jasper.JspCompilationContext;
import org.apache.jasper.Options;
import org.apache.jasper.runtime.JspFactoryImpl;
import org.apache.jasper.security.SecurityClassLoad;
import org.apache.jasper.servlet.JspServletWrapper;
import org.apache.jasper.util.ExceptionUtils;
import org.apache.jasper.util.FastRemovalDequeue;
/**
* Class for tracking JSP compile time file dependencies when the
* >%@include file="..."%< directive is used.
*
* A background thread periodically checks the files a JSP page
* is dependent upon. If a dependent file changes the JSP page
* which included it is recompiled.
*
* Only used if a web application context is a directory.
*
* @author Glenn L. Nielsen
*/
public final class JspRuntimeContext {
// Logger
private final JasperLogger log = JasperLogger.ROOT_LOGGER;
/**
* Counts how many times the webapp's JSPs have been reloaded.
*/
private final AtomicInteger jspReloadCount = new AtomicInteger(0);
/**
* Counts how many times JSPs have been unloaded in this webapp.
*/
private final AtomicInteger jspUnloadCount = new AtomicInteger(0);
/**
* Preload classes required at runtime by a JSP servlet so that
* we don't get a defineClassInPackage security exception.
*/
static {
JspFactoryImpl factory = new JspFactoryImpl();
SecurityClassLoad.securityClassLoad(factory.getClass().getClassLoader());
if (System.getSecurityManager() != null) {
String basePackage = "org.apache.jasper.";
try {
factory.getClass().getClassLoader().loadClass(basePackage +
"runtime.JspFactoryImpl$PrivilegedGetPageContext");
factory.getClass().getClassLoader().loadClass(basePackage +
"runtime.JspFactoryImpl$PrivilegedReleasePageContext");
factory.getClass().getClassLoader().loadClass(basePackage +
"runtime.JspRuntimeLibrary");
factory.getClass().getClassLoader().loadClass(basePackage +
"runtime.JspRuntimeLibrary$PrivilegedIntrospectHelper");
factory.getClass().getClassLoader().loadClass(basePackage +
"runtime.ServletResponseWrapperInclude");
factory.getClass().getClassLoader().loadClass(basePackage +
"servlet.JspServletWrapper");
} catch (ClassNotFoundException ex) {
throw new IllegalStateException(ex);
}
}
JspFactory.setDefaultFactory(factory);
}
// ----------------------------------------------------------- Constructors
/**
* Create a JspRuntimeContext for a web application context.
*
* Loads in any previously generated dependencies from file.
*
* @param context ServletContext for web application
* @param options The main Jasper options
*/
public JspRuntimeContext(ServletContext context, Options options) {
this.context = context;
this.options = options;
// Get the parent class loader
ClassLoader loader = Thread.currentThread().getContextClassLoader();
if (loader == null) {
loader = this.getClass().getClassLoader();
}
if (log.isDebugEnabled()) {
if (loader != null) {
log.debugf("Parent class loader is: '%s' ", loader.toString());
} else {
log.debugf("Parent class loader is: '%s' ", "");
}
}
parentClassLoader = loader;
classpath = initClassPath();
if (Constants.IS_SECURITY_ENABLED) {
SecurityHolder holder = initSecurity();
codeSource = holder.cs;
permissionCollection = holder.pc;
} else {
codeSource = null;
permissionCollection = null;
}
// If this web application context is running from a
// directory, start the background compilation thread
String appBase = context.getRealPath("/");
if (!options.getDevelopment()
&& appBase != null
&& options.getCheckInterval() > 0) {
lastCompileCheck = System.currentTimeMillis();
}
if (options.getMaxLoadedJsps() > 0) {
jspQueue = new FastRemovalDequeue<>(options.getMaxLoadedJsps());
if (log.isDebugEnabled()) {
log.debugf("Created jsp queue with length {%s} for context [%s]", options.getMaxLoadedJsps(), context.getContextPath());
}
}
/* Init parameter is in seconds, locally we use milliseconds */
jspIdleTimeout = options.getJspIdleTimeout() * 1000;
}
// ----------------------------------------------------- Instance Variables
/**
* This web applications ServletContext
*/
private final ServletContext context;
private final Options options;
private final ClassLoader parentClassLoader;
private final PermissionCollection permissionCollection;
private final CodeSource codeSource;
private final String classpath;
private volatile long lastCompileCheck = -1L;
private volatile long lastJspQueueUpdate = System.currentTimeMillis();
/* JSP idle timeout in milliseconds */
private long jspIdleTimeout;
/**
* Maps JSP pages to their JspServletWrapper's
*/
private final Map jsps = new ConcurrentHashMap<>();
/**
* Keeps JSP pages ordered by last access.
*/
private FastRemovalDequeue jspQueue = null;
// ------------------------------------------------------ Public Methods
/**
* Add a new JspServletWrapper.
*
* @param jspUri JSP URI
* @param jsw Servlet wrapper for JSP
*/
public void addWrapper(String jspUri, JspServletWrapper jsw) {
jsps.put(jspUri, jsw);
}
/**
* Get an already existing JspServletWrapper.
*
* @param jspUri JSP URI
* @return JspServletWrapper for JSP
*/
public JspServletWrapper getWrapper(String jspUri) {
return jsps.get(jspUri);
}
/**
* Remove a JspServletWrapper.
*
* @param jspUri JSP URI of JspServletWrapper to remove
*/
public void removeWrapper(String jspUri) {
jsps.remove(jspUri);
}
/**
* Push a newly compiled JspServletWrapper into the queue at first
* execution of jsp. Destroy any JSP that has been replaced in the queue.
*
* @param jsw Servlet wrapper for jsp.
* @return an unloadHandle that can be pushed to front of queue at later execution times.
* */
public FastRemovalDequeue.Entry push(JspServletWrapper jsw) {
if (log.isTraceEnabled()) {
log.tracef("Adding JSP for path [%s] to queue of context [%s]",
jsw.getJspUri(), context.getContextPath());
}
FastRemovalDequeue.Entry entry = jspQueue.push(jsw);
JspServletWrapper replaced = entry.getReplaced();
if (replaced != null) {
if (log.isDebugEnabled()) {
log.debugf("Removing excess JSP for path [%s] from queue of context [%s]",
replaced.getJspUri(), context.getContextPath());
}
unloadJspServletWrapper(replaced);
entry.clearReplaced();
}
return entry;
}
/**
* Push unloadHandle for JspServletWrapper to front of the queue.
*
* @param unloadHandle the unloadHandle for the jsp.
* */
public void makeYoungest(FastRemovalDequeue.Entry unloadHandle) {
if (log.isTraceEnabled()) {
JspServletWrapper jsw = unloadHandle.getContent();
log.tracef("Updating JSP for path [%s] in queue of context [%s]",
jsw.getJspUri(), context.getContextPath());
}
jspQueue.moveFirst(unloadHandle);
}
/**
* Returns the number of JSPs for which JspServletWrappers exist, i.e.,
* the number of JSPs that have been loaded into the webapp.
*
* @return The number of JSPs that have been loaded into the webapp
*/
public int getJspCount() {
return jsps.size();
}
/**
* Get the SecurityManager Policy CodeSource for this web
* application context.
*
* @return CodeSource for JSP
*/
public CodeSource getCodeSource() {
return codeSource;
}
/**
* Get the parent ClassLoader.
*
* @return ClassLoader parent
*/
public ClassLoader getParentClassLoader() {
return parentClassLoader;
}
/**
* Get the SecurityManager PermissionCollection for this
* web application context.
*
* @return PermissionCollection permissions
*/
public PermissionCollection getPermissionCollection() {
return permissionCollection;
}
/**
* Process a "destroy" event for this web application context.
*/
public void destroy() {
Iterator servlets = jsps.values().iterator();
while (servlets.hasNext()) {
servlets.next().destroy();
}
}
/**
* Increments the JSP reload counter.
*/
public void incrementJspReloadCount() {
jspReloadCount.incrementAndGet();
}
/**
* Resets the JSP reload counter.
*
* @param count Value to which to reset the JSP reload counter
*/
public void setJspReloadCount(int count) {
jspReloadCount.set(count);
}
/**
* Gets the current value of the JSP reload counter.
*
* @return The current value of the JSP reload counter
*/
public int getJspReloadCount() {
return jspReloadCount.intValue();
}
/**
* Gets the number of JSPs that are in the JSP limiter queue
*
* @return The number of JSPs (in the webapp with which this JspServlet is
* associated) that are in the JSP limiter queue
*/
public int getJspQueueLength() {
if (jspQueue != null) {
return jspQueue.getSize();
}
return -1;
}
/**
* Gets the number of JSPs that have been unloaded.
*
* @return The number of JSPs (in the webapp with which this JspServlet is
* associated) that have been unloaded
*/
public int getJspUnloadCount() {
return jspUnloadCount.intValue();
}
/**
* Method used by background thread to check the JSP dependencies
* registered with this class for JSP's.
*/
public void checkCompile() {
if (lastCompileCheck < 0) {
// Checking was disabled
return;
}
long now = System.currentTimeMillis();
if (now > (lastCompileCheck + (options.getCheckInterval() * 1000L))) {
lastCompileCheck = now;
} else {
return;
}
Object [] wrappers = jsps.values().toArray();
for (int i = 0; i < wrappers.length; i++ ) {
JspServletWrapper jsw = (JspServletWrapper)wrappers[i];
JspCompilationContext ctxt = jsw.getJspEngineContext();
// JspServletWrapper also synchronizes on this when
// it detects it has to do a reload
synchronized(jsw) {
try {
ctxt.compile();
} catch (FileNotFoundException ex) {
ctxt.incrementRemoved();
} catch (Throwable t) {
ExceptionUtils.handleThrowable(t);
jsw.getServletContext().log(MESSAGES.backgroundCompilationFailed(), t);
}
}
}
}
/**
* @return the classpath that is passed off to the Java compiler.
*/
public String getClassPath() {
return classpath;
}
/**
* @return Last time the update background task has run
*/
public long getLastJspQueueUpdate() {
return lastJspQueueUpdate;
}
// -------------------------------------------------------- Private Methods
/**
* Method used to initialize classpath for compiles.
* @return the compilation classpath
*/
private String initClassPath() {
StringBuilder cpath = new StringBuilder();
if (parentClassLoader instanceof URLClassLoader) {
URL [] urls = ((URLClassLoader)parentClassLoader).getURLs();
for (int i = 0; i < urls.length; i++) {
// Tomcat can use URLs other than file URLs. However, a protocol
// other than file: will generate a bad file system path, so
// only add file: protocol URLs to the classpath.
if (urls[i].getProtocol().equals("file") ) {
try {
// Need to decode the URL, primarily to convert %20
// sequences back to spaces
String decoded = URLDecoder.decode(urls[i].getPath(), "UTF-8");
cpath.append(decoded + File.pathSeparator);
} catch (UnsupportedEncodingException e) {
// All JREs are required to support UTF-8
}
}
}
}
cpath.append(options.getScratchDir() + File.pathSeparator);
String cp = (String) context.getAttribute(Constants.SERVLET_CLASSPATH);
if (cp == null || cp.equals("")) {
cp = options.getClassPath();
}
String path = cpath.toString() + cp;
JasperLogger.COMPILER_LOGGER.logCompilationClasspath(getClassPath());
return path;
}
/**
* Helper class to allow initSecurity() to return two items
*/
private static class SecurityHolder{
private final CodeSource cs;
private final PermissionCollection pc;
private SecurityHolder(CodeSource cs, PermissionCollection pc){
this.cs = cs;
this.pc = pc;
}
}
/**
* Method used to initialize SecurityManager data.
*/
private SecurityHolder initSecurity() {
// Setup the PermissionCollection for this web app context
// based on the permissions configured for the root of the
// web app context directory, then add a file read permission
// for that directory.
Policy policy = Policy.getPolicy();
CodeSource source = null;
PermissionCollection permissions = null;
if( policy != null ) {
try {
// Get the permissions for the web app context
String docBase = context.getRealPath("/");
if( docBase == null ) {
docBase = options.getScratchDir().toString();
}
String codeBase = docBase;
if (!codeBase.endsWith(File.separator)){
codeBase = codeBase + File.separator;
}
File contextDir = new File(codeBase);
URL url = contextDir.getCanonicalFile().toURI().toURL();
//source = new CodeSource(url,(Certificate[])null);
URL providedCodeSource = (URL) context.getAttribute(Constants.CODE_SOURCE_ATTRIBUTE_NAME);
if (providedCodeSource != null) {
source = new CodeSource(providedCodeSource, (Certificate[]) null);
} else {
source = new CodeSource(url, (Certificate[]) null);
}
permissions = policy.getPermissions(source);
PermissionCollection userPermissions = (PermissionCollection) context.getAttribute(Constants.PERMISSION_COLLECTION_ATTRIBUTE_NAME);
if (userPermissions != null) {
Enumeration elements = userPermissions.elements();
while (elements.hasMoreElements()) {
permissions.add(elements.nextElement());
}
}
// Create a file read permission for web app context directory
if (!docBase.endsWith(File.separator)){
permissions.add
(new FilePermission(docBase,"read"));
docBase = docBase + File.separator;
} else {
permissions.add
(new FilePermission
(docBase.substring(0,docBase.length() - 1),"read"));
}
docBase = docBase + "-";
permissions.add(new FilePermission(docBase,"read"));
// Spec says apps should have read/write for their temp
// directory. This is fine, as no security sensitive files, at
// least any that the app doesn't have full control of anyway,
// will be written here.
String workDir = options.getScratchDir().toString();
if (!workDir.endsWith(File.separator)){
permissions.add
(new FilePermission(workDir,"read,write"));
workDir = workDir + File.separator;
}
workDir = workDir + "-";
permissions.add(new FilePermission(
workDir,"read,write,delete"));
// Allow the JSP to access org.apache.jasper.runtime.HttpJspBase
permissions.add( new RuntimePermission(
"accessClassInPackage.org.apache.jasper.runtime") );
} catch(Exception e) {
context.log(MESSAGES.errorInitializingSecurity(), e);
}
}
return new SecurityHolder(source, permissions);
}
private void unloadJspServletWrapper(JspServletWrapper jsw) {
removeWrapper(jsw.getJspUri());
synchronized(jsw) {
jsw.destroy();
}
jspUnloadCount.incrementAndGet();
}
/**
* Method used by background thread to check if any JSP's should be unloaded.
*/
public void checkUnload() {
if (log.isTraceEnabled()) {
int queueLength = -1;
if (jspQueue != null) {
queueLength = jspQueue.getSize();
}
log.tracef("Checking JSPs for unload in context [%s], JSP count: {%s} queue length: {%s}",
context.getContextPath(), "" + jsps.size(), "" + queueLength);
}
long now = System.currentTimeMillis();
if (jspIdleTimeout > 0) {
long unloadBefore = now - jspIdleTimeout;
Object [] wrappers = jsps.values().toArray();
for (int i = 0; i < wrappers.length; i++ ) {
JspServletWrapper jsw = (JspServletWrapper)wrappers[i];
synchronized(jsw) {
if (jsw.getLastUsageTime() < unloadBefore) {
if (log.isDebugEnabled()) {
log.debugf("Removing idle JSP for path [%s] in context [%s] after %s seconds",
jsw.getJspUri(), context.getContextPath(),
"" + (now-jsw.getLastUsageTime()));
}
if (jspQueue != null) {
jspQueue.remove(jsw.getUnloadHandle());
}
unloadJspServletWrapper(jsw);
}
}
}
}
lastJspQueueUpdate = now;
}
public void handleFileChange(Set changedResource) {
for (String resource : changedResource) {
String slashResource = resource.startsWith("/") ? resource : "/" + resource;
JspServletWrapper wrapper = jsps.get(slashResource);
if (wrapper != null) {
wrapper.jspFileChanged();
}
}
}
}
