/*
* 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.cocoon.components.language.generator;
import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.component.ComponentException;
import org.apache.avalon.framework.component.ComponentManager;
import org.apache.avalon.framework.component.ComponentSelector;
import org.apache.avalon.framework.component.Composable;
import org.apache.avalon.framework.component.Recomposable;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.parameters.ParameterException;
import org.apache.avalon.framework.parameters.Parameterizable;
import org.apache.avalon.framework.parameters.Parameters;
import org.apache.avalon.framework.thread.ThreadSafe;
import org.apache.cocoon.Constants;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.components.classloader.ClassLoaderManager;
import org.apache.cocoon.components.language.LanguageException;
import org.apache.cocoon.components.language.markup.MarkupLanguage;
import org.apache.cocoon.components.language.programming.CodeFormatter;
import org.apache.cocoon.components.language.programming.Program;
import org.apache.cocoon.components.language.programming.ProgrammingLanguage;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.cocoon.util.IOUtils;
import org.apache.excalibur.source.Source;
import java.io.File;
import java.net.MalformedURLException;
/**
* The default implementation of <code>ProgramGenerator</code>
*
* @author <a href="mailto:ricardo@apache.org">Ricardo Rocha</a>
* @author <a href="mailto:vgritsenko@apache.org">Vadim Gritsenko</a>
* @author <a href="mailto:tcurdt@apache.org">Torsten Curdt</a>
* @version CVS $Id$
*/
public class ProgramGeneratorImpl extends AbstractLogEnabled
implements ProgramGenerator, Contextualizable, Composable, Parameterizable,
Disposable, ThreadSafe {
/** The auto-reloading option */
protected boolean autoReload = true;
/** The pre-loading option */
protected boolean preload = false;
/** The check for manual source changes in the repository*/
protected boolean watchSource = false;
/**
* The ComponentSelector for programs. Caches Program by program
* source file.
*/
protected GeneratorSelector cache;
/** The component manager */
protected ComponentManager manager;
/** The markup language component selector */
protected ComponentSelector markupSelector;
/** The programming language component selector */
protected ComponentSelector languageSelector;
/** The working directory */
protected File workDir;
/** The ClassLoaderManager */
protected ClassLoaderManager classManager;
/** The root package */
protected String rootPackage;
/** Servlet Context Directory */
protected String contextDir;
/** Contextualize this class */
public void contextualize(Context context) throws ContextException {
if (this.workDir == null) {
this.workDir = (File) context.get(Constants.CONTEXT_WORK_DIR);
}
if (this.contextDir == null) {
org.apache.cocoon.environment.Context ctx =
(org.apache.cocoon.environment.Context) context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
// Determine the context directory, preferably as a file
// FIXME (SW) - this is purposely redundant with some code in CocoonServlet
// to have the same rootPath. How to avoid this ?
try {
String rootPath = ctx.getRealPath("/");
if (rootPath != null) {
this.contextDir = new File(rootPath).toURL().toExternalForm();
} else {
String webInf = ctx.getResource("/WEB-INF").toExternalForm();
this.contextDir = webInf.substring(0, webInf.length() - "WEB-INF".length());
}
if (getLogger().isDebugEnabled()) {
getLogger().debug("Context directory is " + this.contextDir);
}
} catch (MalformedURLException e) {
getLogger().warn("Could not get context directory", e);
this.contextDir = "";
}
}
}
/**
* Set the global component manager. This method also sets the
* <code>ComponentSelector</code> used as language factory for both markup
* and programming languages.
* @param manager The global component manager
*/
public void compose(ComponentManager manager) throws ComponentException {
if (this.manager == null && manager != null) {
this.manager = manager;
this.cache = (GeneratorSelector) this.manager.lookup(GeneratorSelector.ROLE + "Selector");
this.markupSelector = (ComponentSelector)this.manager.lookup(MarkupLanguage.ROLE + "Selector");
this.languageSelector = (ComponentSelector)this.manager.lookup(ProgrammingLanguage.ROLE + "Selector");
this.classManager = (ClassLoaderManager)this.manager.lookup(ClassLoaderManager.ROLE);
}
}
/**
* Set the sitemap-provided configuration. This method sets the persistent code repository and the auto-reload option
* @param params The configuration information
* @exception ParameterException Not thrown here
*/
public void parameterize(Parameters params) throws ParameterException {
this.autoReload = params.getParameterAsBoolean("auto-reload", autoReload);
this.rootPackage = params.getParameter("root-package", "org.apache.cocoon.www");
this.preload = params.getParameterAsBoolean("preload", preload);
this.watchSource = params.getParameterAsBoolean("watch-source", watchSource);
}
/**
* Generates program source file name in the working directory
* from the source SystemID
*/
private String getNormalizedName(final String systemId) {
StringBuffer contextFilename = new StringBuffer(this.rootPackage.replace('.', File.separatorChar));
contextFilename.append(File.separator);
if(systemId.startsWith(this.contextDir)) {
// VG: File is located under contextDir; using relative file name ...
contextFilename.append(systemId.substring(this.contextDir.length()));
} else {
// VG: File is located outside of contextDir; using systemId ...
contextFilename.append(systemId);
}
return IOUtils.normalizedFilename(contextFilename.toString());
}
/**
* Load a program built from an XML document written in a <code>MarkupLanguage</code>
*
* @param fileName The input document's <code>File</code>
* @param markupLanguageName The <code>MarkupLanguage</code> in which the input document is written
* @param programmingLanguageName The <code>ProgrammingLanguage</code> in which the program must be written
* @return The loaded program instance
* @exception Exception If an error occurs during generation or loading
* @deprecated Pass Source object instead of file name.
*/
public CompiledComponent load(ComponentManager newManager,
String fileName,
String markupLanguageName,
String programmingLanguageName,
SourceResolver resolver)
throws Exception {
final Source source = resolver.resolveURI(fileName);
try {
return load(newManager, source, markupLanguageName, programmingLanguageName, resolver);
} finally {
resolver.release(source);
}
}
/**
* Load a program built from an XML document written in a <code>MarkupLanguage</code>.
*
* This method does not releases passed source object. Caller of the method must release
* source when needed.
*
* @param source The input document's <code>File</code>
* @param markupLanguageName The <code>MarkupLanguage</code> in which the input document is written
* @param programmingLanguageName The <code>ProgrammingLanguage</code> in which the program must be written
* @return The loaded program instance
* @exception Exception If an error occurs during generation or loading
*/
public CompiledComponent load(ComponentManager newManager,
Source source,
String markupLanguageName,
String programmingLanguageName,
SourceResolver resolver)
throws Exception {
final String id = source.getURI();
ProgrammingLanguage programmingLanguage = null;
MarkupLanguage markupLanguage = null;
try {
// Create file name for the program generated from the provided source.
final String normalizedName = getNormalizedName(id);
if (getLogger().isDebugEnabled()) {
getLogger().debug("Loading serverpage systemId=[" + id + "]" +
" markupLanguageName=[" + markupLanguageName + "]" +
" programmingLanguageName=[" + programmingLanguageName + "]" +
" -> normalizedName=[" + normalizedName + "]");
}
markupLanguage = (MarkupLanguage) this.markupSelector.select(markupLanguageName);
programmingLanguage = (ProgrammingLanguage) this.languageSelector.select(programmingLanguageName);
programmingLanguage.setLanguageName(programmingLanguageName);
Program program = null;
CompiledComponent programInstance = null;
// Attempt to load program object from cache
try {
programInstance = (CompiledComponent) this.cache.select(normalizedName);
} catch (Exception e) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("The serverpage [" + id + "] is not in the cache yet");
}
}
if (programInstance == null && this.preload) {
// Preloading: Load program if its source/[object file] is available
try {
program = programmingLanguage.preload(normalizedName,
this.workDir,
markupLanguage.getEncoding());
this.cache.addGenerator(newManager, normalizedName, program);
programInstance = (CompiledComponent) this.cache.select(normalizedName);
if (getLogger().isDebugEnabled()) {
getLogger().debug("Successfully preloaded serverpage [" + id + "]");
}
} catch (Exception e) {
if (getLogger().isInfoEnabled()) {
getLogger().info("The serverpage [" + id
+ "] could not be preloaded, will be re-created ("
+ e + ")");
}
}
}
if (programInstance == null) {
synchronized (this) {
// Attempt again to load program object from cache.
// This avoids that simultaneous requests recompile
// the same XSP over and over again.
try {
programInstance = (CompiledComponent) this.cache.select(normalizedName);
if (getLogger().isDebugEnabled()) {
getLogger().debug("The serverpage [" + id + "] was now in the cache");
}
} catch (Exception e) {
// no instance found
if (getLogger().isDebugEnabled()) {
getLogger().debug("Creating new serverpage for [" + id + "]");
}
generateSourcecode(source,
normalizedName,
markupLanguage,
programmingLanguage);
programInstance = loadProgram(newManager,
normalizedName,
markupLanguage,
programmingLanguage);
}
}
} else {
// found an instance
if (this.autoReload) {
long sourceLastModified = source.getLastModified();
// Has XSP changed?
// Note : lastModified can be 0 if source is dynamically generated.
// In that case, let the program instance decide if it is modified or not.
if (programInstance.modifiedSince(sourceLastModified)) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("ReCreating serverpage for [" + id + "]");
}
synchronized (this) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Releasing old serverpage program [" + id + "]");
}
release(programInstance);
programmingLanguage.unload(program, normalizedName, this.workDir);
this.cache.removeGenerator(normalizedName);
programInstance = null;
program = null;
generateSourcecode(source,
normalizedName,
markupLanguage,
programmingLanguage);
programInstance = loadProgram(newManager,
normalizedName,
markupLanguage,
programmingLanguage);
}
} else {
// check the repository for changes at all?
if (this.watchSource) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Checking sourcecode of [" + id + "] for a change");
}
File sourcecodeFile = new File(this.workDir,
normalizedName + "." + programmingLanguage.getSourceExtension());
// has sourcecode in repository changed ?
if (sourcecodeFile != null && sourcecodeFile.exists()) {
long sourcecodeLastModified = sourcecodeFile.lastModified();
if (sourcecodeLastModified > sourceLastModified
|| sourceLastModified == 0
|| sourcecodeLastModified == 0) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Create new serverpage program for [" + id + "] - repository has changed");
}
synchronized (this) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Releasing old serverpage program [" + id + "]");
}
release(programInstance);
//programmingLanguage.unload(program, normalizedName, this.workDir);
this.cache.removeGenerator(normalizedName);
programInstance = null;
program = null;
programInstance = loadProgram(newManager,
normalizedName,
markupLanguage,
programmingLanguage);
}
} else {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Sourcecode of [" + id + "] has not changed - returning program from cache");
}
}
} else {
if (getLogger().isErrorEnabled()) {
getLogger().error("Could not find sourcecode for [" + id + "]");
}
}
}
}
} else {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Not checking for modifications [autoReload=false] - using current version");
}
}
}
// Recompose with the new manager if program needs it.
// This is required to provide XSP with manager from the correct
// sitemap so it will be able to find all components declared in
// the sitemap.
if (programInstance instanceof Recomposable) {
((Recomposable) programInstance).recompose(newManager);
}
return (programInstance);
} finally {
this.markupSelector.release(markupLanguage);
this.languageSelector.release(programmingLanguage);
}
}
private CompiledComponent loadProgram(ComponentManager newManager,
String normalizedName,
MarkupLanguage markupLanguage,
ProgrammingLanguage programmingLanguage)
throws Exception {
CompiledComponent programInstance = null;
try {
return (CompiledComponent) this.cache.select(normalizedName);
} catch (Exception e) {
}
try {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Loading program [" + normalizedName + "]");
}
Program program = programmingLanguage.load(normalizedName, this.workDir, markupLanguage.getEncoding());
this.cache.addGenerator(newManager, normalizedName, program);
if (getLogger().isDebugEnabled()) {
getLogger().debug("Successfully loaded program [" + normalizedName + "]");
}
} catch (LanguageException le) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Got Language Exception", le);
}
throw new ProcessingException("Language Exception", le);
}
try {
programInstance = (CompiledComponent) this.cache.select(normalizedName);
} catch (Exception cme) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Can't load ServerPage: got exception", cme);
}
throw new ProcessingException("Can't load ServerPage", cme);
}
return (programInstance);
}
private void generateSourcecode(Source source,
String normalizedName,
MarkupLanguage markupLanguage,
ProgrammingLanguage programmingLanguage)
throws Exception {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Creating sourcecode for [" + source.getURI() + "]");
}
// Generate code
String code = markupLanguage.generateCode(source, normalizedName, programmingLanguage);
if (code == null || code.length() == 0) {
// FIXME(VG): Xalan with incremental-processing=true does not propagate exceptions
// from working thread to main thread. See
// http://nagoya.apache.org/bugzilla/show_bug.cgi?id=8033
throw new ProcessingException("Failed to generate program code (this may happen " +
"if you use Xalan in incremental processing mode). " +
"Please check log file and/or console for errors.");
}
String encoding = markupLanguage.getEncoding();
// Format source code if applicable
CodeFormatter codeFormatter = programmingLanguage.getCodeFormatter();
if (codeFormatter != null) {
code = codeFormatter.format(code, encoding);
}
// Store generated code
final File sourceFile = new File(this.workDir, normalizedName + "." + programmingLanguage.getSourceExtension());
final File sourceDir = sourceFile.getParentFile();
if (sourceDir != null) {
sourceDir.mkdirs();
}
IOUtils.serializeString(sourceFile, code);
if (getLogger().isDebugEnabled()) {
getLogger().debug("Successfully created sourcecode for [" + source.getURI() + "]");
}
}
/**
* Releases the program instance.
* @param component program instance to be released
*/
public void release(CompiledComponent component) {
this.cache.release(component);
}
/**
* Removes named program from the program generator's cache.
* Disposes all created instances of the program.
* @param source of the program to be removed
*/
public void remove(Source source) {
final String normalizedName = getNormalizedName(source.getURI());
this.cache.removeGenerator(normalizedName);
}
/**
* dispose
*/
public void dispose() {
this.manager.release(this.cache);
this.cache = null;
this.manager.release(this.markupSelector);
this.markupSelector = null;
this.manager.release(this.languageSelector);
this.languageSelector = null;
this.manager.release(this.classManager);
this.classManager = null;
this.manager = null;
this.workDir = null;
this.contextDir = null;
}
}