/*
* Copyright 1999-2004 The Apache Software Foundation.
*
* 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.apache.cocoon.components.flow.javascript.fom;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Reader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.avalon.framework.CascadingRuntimeException;
import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.configuration.Configurable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.ResourceNotFoundException;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.components.flow.AbstractInterpreter;
import org.apache.cocoon.components.flow.Interpreter;
import org.apache.cocoon.components.flow.InvalidContinuationException;
import org.apache.cocoon.components.flow.WebContinuation;
import org.apache.cocoon.components.flow.javascript.JSErrorReporter;
import org.apache.cocoon.components.flow.javascript.ScriptablePointerFactory;
import org.apache.cocoon.components.flow.javascript.ScriptablePropertyHandler;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Redirector;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.environment.Session;
import org.apache.commons.jxpath.JXPathIntrospector;
import org.apache.commons.jxpath.ri.JXPathContextReferenceImpl;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;
import org.mozilla.javascript.Context;
import org.mozilla.javascript.EcmaError;
import org.mozilla.javascript.EvaluatorException;
import org.mozilla.javascript.JavaScriptException;
import org.mozilla.javascript.Script;
import org.mozilla.javascript.ScriptRuntime;
import org.mozilla.javascript.Scriptable;
import org.mozilla.javascript.ScriptableObject;
import org.mozilla.javascript.Wrapper;
import org.mozilla.javascript.continuations.Continuation;
import org.mozilla.javascript.tools.ToolErrorReporter;
import org.mozilla.javascript.tools.shell.Global;
/**
* <p>Interface with the JavaScript interpreter.</p>
* <p>This version of the JavaScript interpreter provides enhanced
* functionality and supports interception.</p>
*
* <p>Changes:
* <ul>
* <li>Use of the AO_FOM_Cocoon object encapsulating the Cocoon object.
* All references to the FOM_Cocoon object had to be changed.
* </li>
* <li>Additional configurations</li>
* <li>adding the <code>JavaScriptAspectWeaver</code> to the SourceEntry
* object if interceptions are enabled</li>
* </ul>
* </p>
*
* @author <a href="mailto:ovidiu@apache.org">Ovidiu Predescu</a>
* @author <a href="mailto:crafterm@apache.org">Marcus Crafter</a>
* @author <a href="mailto:coliver@apache.org">Christopher Oliver</a>
* @author <a href="mailto:reinhard@apache.org">Reinhard P�tz</a>
* @since 2.1
* @version CVS $Id: AO_FOM_JavaScriptInterpreter.java,v 1.9 2004/03/05 10:07:25 bdelacretaz Exp $
*/
public class AO_FOM_JavaScriptInterpreter extends AbstractInterpreter
implements Serviceable, Configurable, Initializable
{
private SourceResolver sourceResolver;
/**
* LAST_EXEC_TIME
* A long value is stored under this key in each top level JavaScript
* thread scope object. When you enter a context any scripts whose
* modification time is later than this value will be recompiled and reexecuted,
* and this value will be updated to the current time.
*/
private final static String LAST_EXEC_TIME = "__PRIVATE_LAST_EXEC_TIME__";
/**
* Key for storing a JavaScript global scope object in the Cocoon session
*/
public static final String USER_GLOBAL_SCOPE = "FOM JavaScript GLOBAL SCOPE";
// This is the only optimization level that supports continuations
// in the Christoper Oliver's Rhino JavaScript implementation
static int OPTIMIZATION_LEVEL = -2;
// the postfix of the resulting file streamed into the same directory as
// the basescript
// (RPO) added/changed by interception layer
public static final String INTERCEPTION_POSTFIX = "_intercepted.js";
// end
/**
* When was the last time we checked for script modifications. Used
* only if {@link #reloadScripts} is true.
*/
protected long lastTimeCheck = 0;
// (RPO) added/changed by interception layer
/**
* Are interceptions enabled?
*/
private boolean isInterceptionEnabled;
// end
/**
* Shared global scope for scripts and other immutable objects
*/
Global scope;
/**
* List of <code>String</code> objects that represent files to be
* read in by the JavaScript interpreter.
*/
List topLevelScripts = new ArrayList();
class ScriptSourceEntry {
final private Source source;
private Script script;
private long compileTime;
public ScriptSourceEntry(Source source) {
this.source = source;
}
public ScriptSourceEntry(Source source, Script script, long t) {
this.source = source;
this.script = script;
this.compileTime = t;
}
public Source getSource() {
return source;
}
// (RPO) added/changed by interception layer
private JavaScriptAspectWeaver aspectWeaver = null;
public void setAspectWeaver( JavaScriptAspectWeaver aspectWeaver ) {
this.aspectWeaver = aspectWeaver;
}
public Script getScript(Context context, Scriptable scope,
boolean refresh)
throws Exception {
if (refresh) {
source.refresh();
}
if (script == null || compileTime < source.getLastModified()) {
script = compileScript(context, scope, source, aspectWeaver);
compileTime = source.getLastModified();
}
return script;
}
// -- end
}
/**
* Mapping of String objects (source uri's) to ScriptSourceEntry's
*
*/
Map compiledScripts = new HashMap();
JSErrorReporter errorReporter;
boolean enableDebugger = false;
/**
* JavaScript debugger: there's only one of these: it can debug multiple
* threads executing JS code.
*/
static org.mozilla.javascript.tools.debugger.Main debugger;
static synchronized org.mozilla.javascript.tools.debugger.Main getDebugger() {
if (debugger == null) {
final org.mozilla.javascript.tools.debugger.Main db
= new org.mozilla.javascript.tools.debugger.Main("Cocoon Flow Debugger");
db.pack();
java.awt.Dimension size =
java.awt.Toolkit.getDefaultToolkit().getScreenSize();
size.width *= 0.75;
size.height *= 0.75;
db.setSize(size);
db.setExitAction(new Runnable() {
public void run() {
db.setVisible(false);
}
});
db.setOptimizationLevel(OPTIMIZATION_LEVEL);
db.setVisible(true);
debugger = db;
Context.addContextListener(debugger);
}
return debugger;
}
// (RPO) added by interception layer
Configuration stopExecutionFunctionsConf = null;
boolean serializeResultScript = false;
// --end
public void service(ServiceManager manager) throws ServiceException {
super.service(manager);
this.sourceResolver = (SourceResolver)manager.lookup(SourceResolver.ROLE);
}
public void configure(Configuration config)
throws ConfigurationException {
super.configure(config);
String loadOnStartup
= config.getChild("load-on-startup", true).getValue(null);
if (loadOnStartup != null) {
register(loadOnStartup);
}
String debugger
= config.getChild("debugger").getValue(null);
if ("enabled".equalsIgnoreCase(debugger)) {
enableDebugger = true;
}
// (RPO) added by interception layer
isInterceptionEnabled =
config.getChild( "enable-interception" ).getValueAsBoolean( true );
stopExecutionFunctionsConf =
config.getChild( "cont-creating-functions" );
serializeResultScript =
config.getChild( "serialize-result-script" ).getValueAsBoolean( false );
// --end
}
public void initialize()
throws Exception
{
if (enableDebugger) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Flow debugger enabled, creating");
}
getDebugger().doBreak();
}
Context context = Context.enter();
context.setOptimizationLevel(OPTIMIZATION_LEVEL);
context.setCompileFunctionsWithDynamicScope(true);
context.setGeneratingDebug(true);
// add support for Rhino objects to JXPath
JXPathIntrospector.registerDynamicClass(org.mozilla.javascript.Scriptable.class,
ScriptablePropertyHandler.class);
JXPathContextReferenceImpl.addNodePointerFactory(new ScriptablePointerFactory());
try {
scope = new Global(context);
// Access to Cocoon internal objects
AO_FOM_Cocoon.init(scope);
errorReporter = new JSErrorReporter(getLogger());
}
catch (Exception e) {
Context.exit();
e.printStackTrace();
throw e;
}
}
/**
* Returns the JavaScript scope, a Scriptable object, from the user
* session instance. Each URI prefix, as returned by the {@link
* org.apache.cocoon.environment.Environment#getURIPrefix} method,
* can have a scope associated with it.
*
* @param environment an <code>Environment</code> value
* @return a <code>Scriptable</code> value
*/
private Scriptable getSessionScope()
throws Exception {
Request request = ContextHelper.getRequest(avalonContext);
Scriptable scope = null;
Session session = request.getSession(false);
if (session != null) {
HashMap userScopes = (HashMap)session.getAttribute(USER_GLOBAL_SCOPE);
if (userScopes != null) {
// Get context prefix
Source src = this.sourceResolver.resolveURI(".");
String uriPrefix = src.getURI();
this.sourceResolver.release(src);
scope = (Scriptable)userScopes.get(uriPrefix);
}
}
if (scope == null) {
scope = createThreadScope();
}
return scope;
}
void updateSession(Scriptable scope) throws Exception {
ThreadScope thrScope = (ThreadScope)scope;
if (thrScope.useSession) {
setSessionScope(scope);
}
}
/**
* Associates a JavaScript scope, a Scriptable object, with the URI
* prefix of the current sitemap, as returned by the {@link
* org.apache.cocoon.environment.Environment#getURIPrefix} method.
*
* @param environment an <code>Environment</code> value
* @param scope a <code>Scriptable</code> value
*/
private Scriptable setSessionScope(Scriptable scope)
throws Exception {
Request request = ContextHelper.getRequest(this.avalonContext);
Session session = request.getSession(true);
HashMap userScopes = (HashMap)session.getAttribute(USER_GLOBAL_SCOPE);
if (userScopes == null) {
userScopes = new HashMap();
session.setAttribute(USER_GLOBAL_SCOPE, userScopes);
}
// Get context prefix
Source src = this.sourceResolver.resolveURI(".");
String uriPrefix = src.getURI();
this.sourceResolver.release(src);
userScopes.put(uriPrefix, scope);
return scope;
}
public static class ThreadScope extends ScriptableObject {
/* true if this scope has assigned any global vars */
boolean useSession = false;
public ThreadScope() {
}
public String getClassName() {
return "ThreadScope";
}
public void put(String name, Scriptable start,
Object value) {
useSession = true;
super.put(name, start, value);
}
public void put(int index, Scriptable start,
Object value) {
useSession = true;
super.put(index, start, value);
}
void reset() {
useSession = false;
}
}
private Scriptable createThreadScope()
throws Exception {
org.mozilla.javascript.Context context =
org.mozilla.javascript.Context.getCurrentContext();
ThreadScope thrScope = new ThreadScope();
thrScope.setPrototype(scope);
// We want 'thrScope' to be a new top-level scope, so set its
// parent scope to null. This means that any variables created
// by assignments will be properties of "thrScope".
thrScope.setParentScope(null);
// Put in the thread scope the Cocoon object, which gives access
// to the interpreter object, and some Cocoon objects. See
// FOM_Cocoon for more details.
Object args[] = {};
AO_FOM_Cocoon cocoon = (AO_FOM_Cocoon)
context.newObject(thrScope, "AO_FOM_Cocoon", args);
cocoon.setParentScope(thrScope);
thrScope.put("cocoon", thrScope, cocoon);
((ScriptableObject)thrScope).defineProperty(LAST_EXEC_TIME,
new Long(0),
ScriptableObject.DONTENUM |
ScriptableObject.PERMANENT);
thrScope.reset();
return thrScope;
}
/**
* Returns a new Scriptable object to be used as the global scope
* when running the JavaScript scripts in the context of a request.
*
* <p>If you want to maintain the state of global variables across
* multiple invocations of <code><map:call
* function="..."></code>, you need to instanciate the session
* object which is a property of the cocoon object
* <code>var session = cocoon.session</code>. This will place the
* newly create Scriptable object in the user's session, where it
* will be retrieved from at the next invocation of {@link #callFunction}.</p>
*
* @param environment an <code>Environment</code> value
* @exception Exception if an error occurs
*/
private void setupContext(Redirector redirector,
org.mozilla.javascript.Context context,
Scriptable thrScope)
throws Exception {
// Try to retrieve the scope object from the session instance. If
// no scope is found, we create a new one, but don't place it in
// the session.
//
// When a user script "creates" a session using
// cocoon.createSession() in JavaScript, the thrScope is placed in
// the session object, where it's later retrieved from here. This
// behaviour allows multiple JavaScript functions to share the
// same global scope.
AO_FOM_Cocoon cocoon = (AO_FOM_Cocoon)thrScope.get("cocoon", thrScope);
long lastExecTime = ((Long)thrScope.get(LAST_EXEC_TIME,
thrScope)).longValue();
// We need to setup the FOM_Cocoon object according to the current
// request. Everything else remains the same.
cocoon.setup( this, redirector, avalonContext, manager, getLogger());
// Check if we need to compile and/or execute scripts
synchronized (compiledScripts) {
List execList = new ArrayList();
boolean needsRefresh = false;
if (reloadScripts) {
long now = System.currentTimeMillis();
if (now >= lastTimeCheck + checkTime) {
needsRefresh = true;
}
lastTimeCheck = now;
}
// If we've never executed scripts in this scope or
// if reload-scripts is true and the check interval has expired
// or if new scripts have been specified in the sitemap,
// then create a list of scripts to compile/execute
if (lastExecTime == 0 || needsRefresh || needResolve.size() > 0) {
topLevelScripts.addAll(needResolve);
if (lastExecTime != 0 && !needsRefresh) {
execList.addAll(needResolve);
} else {
execList.addAll(topLevelScripts);
}
needResolve.clear();
}
// Compile all the scripts first. That way you can set breakpoints
// in the debugger before they execute.
for (int i = 0, size = execList.size(); i < size; i++) {
String sourceURI = (String)execList.get(i);
ScriptSourceEntry entry =
(ScriptSourceEntry)compiledScripts.get(sourceURI);
if (entry == null) {
Source src = this.sourceResolver.resolveURI(sourceURI);
entry = new ScriptSourceEntry(src);
compiledScripts.put(sourceURI, entry);
}
// (RPO) added/changed by interception layer
// add interception support
if( isInterceptionEnabled ) {
JavaScriptAspectWeaver aspectWeaver = new JavaScriptAspectWeaver();
aspectWeaver.enableLogging( this.getLogger() );
aspectWeaver.service(this.manager);
aspectWeaver.setSerializeResultScriptParam( this.serializeResultScript );
aspectWeaver.setStopExecutionFunctionsConf( this.stopExecutionFunctionsConf );
entry.setAspectWeaver( aspectWeaver );
}
// --end
// Compile the script if necessary
entry.getScript(context, this.scope, needsRefresh);
}
// Execute the scripts if necessary
for (int i = 0, size = execList.size(); i < size; i++) {
String sourceURI = (String)execList.get(i);
ScriptSourceEntry entry =
(ScriptSourceEntry)compiledScripts.get(sourceURI);
long lastMod = entry.getSource().getLastModified();
Script script = entry.getScript(context, this.scope, false);
if (lastExecTime == 0 || lastMod > lastExecTime) {
script.exec(context, thrScope);
thrScope.put(LAST_EXEC_TIME, thrScope,
new Long(System.currentTimeMillis()));
((ThreadScope)thrScope).reset();
}
}
}
}
/**
* Compile filename as JavaScript code
*
* @param cx Rhino context
* @param fileName resource uri
* @return compiled script
*/
Script compileScript(Context cx,
String fileName) throws Exception {
Source src = sourceResolver.resolveURI(fileName);
if (src == null) {
throw new ResourceNotFoundException(fileName + ": not found");
}
synchronized (compiledScripts) {
ScriptSourceEntry entry =
(ScriptSourceEntry)compiledScripts.get(src.getURI());
Script compiledScript = null;
if (entry == null) {
compiledScripts.put(src.getURI(),
entry = new ScriptSourceEntry(src));
}
compiledScript = entry.getScript(cx, this.scope, false);
return compiledScript;
}
}
// (RPO) added/changed by interception layer
protected Script compileScript( Context cx, Scriptable scope,
Source src, JavaScriptAspectWeaver aspectWeaver)
throws Exception {
Script compiledScript = null;
boolean areScriptsApplied = false;
// test base script if scripts are applied to
if( aspectWeaver != null ) {
aspectWeaver.setBaseScript( src );
areScriptsApplied = aspectWeaver.areScriptsApplied();
}
// no scripts applied or compileScript was called with null AspectWeaver
if( aspectWeaver == null || ! areScriptsApplied ) {
InputStream is = src.getInputStream();
if (is == null) {
throw new ResourceNotFoundException(src.getURI() + ": not found");
}
Reader reader = new BufferedReader(new InputStreamReader(is));
compiledScript = cx.compileReader(scope, reader, src.getURI(), 1, null );
}
// script applied
else {
this.getLogger().info( "Adding interceptions to script " + src.getURI() );
Reader reader = new BufferedReader(
aspectWeaver.getInterceptedScriptAsReader() );
compiledScript = cx.compileReader(scope, reader, src.getURI() + INTERCEPTION_POSTFIX, 1, null );
}
return compiledScript;
}
// -- end
/**
* Calls a JavaScript function, passing <code>params</code> as its
* arguments. In addition to this, it makes available the parameters
* through the <code>cocoon.parameters</code> JavaScript array
* (indexed by the parameter names).
*
* @param funName a <code>String</code> value
* @param params a <code>List</code> value
* @param redirector
* @exception Exception if an error occurs
*/
public void callFunction(String funName, List params,
Redirector redirector)
throws Exception
{
Context context = Context.enter();
context.setOptimizationLevel(OPTIMIZATION_LEVEL);
context.setGeneratingDebug(true);
context.setCompileFunctionsWithDynamicScope(true);
context.setErrorReporter(errorReporter);
AO_FOM_Cocoon cocoon = null;
Scriptable thrScope = getSessionScope();
synchronized (thrScope) {
try {
setupContext(redirector, context, thrScope);
cocoon = (AO_FOM_Cocoon)thrScope.get("cocoon", thrScope);
if (enableDebugger) {
if (!getDebugger().isVisible()) {
// only raise the debugger window if it isn't already visible
getDebugger().setVisible(true);
}
}
int size = (params != null ? params.size() : 0);
Object[] funArgs = new Object[size];
Scriptable parameters = context.newObject(thrScope);
if (size != 0) {
for (int i = 0; i < size; i++) {
Interpreter.Argument arg = (Interpreter.Argument)params.get(i);
funArgs[i] = arg.value;
if (arg.name == null) arg.name = "";
parameters.put(arg.name, parameters, arg.value);
}
}
cocoon.setParameters(parameters);
Object fun = ScriptableObject.getProperty(thrScope, funName);
if (fun == Scriptable.NOT_FOUND) {
throw new ResourceNotFoundException("Function \"javascript:"+funName+ "()\" not found");
}
ScriptRuntime.call(context, fun, thrScope,
funArgs, thrScope);
} catch (JavaScriptException ex) {
EvaluatorException ee =
Context.reportRuntimeError(ToolErrorReporter.getMessage("msg.uncaughtJSException",
ex.getMessage()));
Throwable unwrapped = unwrap(ex);
if (unwrapped instanceof ProcessingException) {
throw (ProcessingException)unwrapped;
}
throw new CascadingRuntimeException(ee.getMessage(), unwrapped);
} catch (EcmaError ee) {
String msg = ToolErrorReporter.getMessage("msg.uncaughtJSException", ee.toString());
if (ee.getSourceName() != null) {
Context.reportRuntimeError(msg,
ee.getSourceName(),
ee.getLineNumber(),
ee.getLineSource(),
ee.getColumnNumber());
} else {
Context.reportRuntimeError(msg);
}
throw new CascadingRuntimeException(ee.getMessage(), ee);
} finally {
updateSession(thrScope);
if (cocoon != null) cocoon.invalidate();
Context.exit();
}
}
}
public void handleContinuation(String id, List params,
Redirector redirector)
throws Exception
{
WebContinuation wk = continuationsMgr.lookupWebContinuation(id);
if (wk == null) {
/*
* Throw an InvalidContinuationException to be handled inside the
* <map:handle-errors> sitemap element.
*/
throw new InvalidContinuationException("The continuation ID " + id + " is invalid.");
}
Context context = Context.enter();
context.setOptimizationLevel(OPTIMIZATION_LEVEL);
context.setGeneratingDebug(true);
context.setCompileFunctionsWithDynamicScope(true);
// Obtain the continuation object from it, and setup the
// FOM_Cocoon object associated in the dynamic scope of the saved
// continuation with the environment and context objects.
Continuation k = (Continuation)wk.getContinuation();
Scriptable kScope = k.getParentScope();
synchronized (kScope) {
AO_FOM_Cocoon cocoon = (AO_FOM_Cocoon)kScope.get("cocoon", kScope);
cocoon.setup(this, redirector, avalonContext, manager, getLogger());
if (enableDebugger) {
getDebugger().setVisible(true);
}
int size = (params != null ? params.size() : 0);
Scriptable parameters = context.newObject(kScope);
if (size != 0) {
for (int i = 0; i < size; i++) {
Interpreter.Argument arg = (Interpreter.Argument)params.get(i);
parameters.put(arg.name, parameters, arg.value);
}
}
cocoon.setParameters(parameters);
FOM_WebContinuation fom_wk =
new FOM_WebContinuation(wk);
fom_wk.setParentScope(kScope);
fom_wk.setPrototype(ScriptableObject.getClassPrototype(kScope,
fom_wk.getClassName()));
Object[] args = new Object[] {k, fom_wk};
try {
ScriptableObject.callMethod(cocoon,
"handleContinuation",
args);
} catch (JavaScriptException ex) {
EvaluatorException ee =
Context.reportRuntimeError(ToolErrorReporter.getMessage("msg.uncaughtJSException",
ex.getMessage()));
Throwable unwrapped = unwrap(ex);
if (unwrapped instanceof ProcessingException) {
throw (ProcessingException)unwrapped;
}
throw new CascadingRuntimeException(ee.getMessage(), unwrapped);
} catch (EcmaError ee) {
String msg = ToolErrorReporter.getMessage("msg.uncaughtJSException", ee.toString());
if (ee.getSourceName() != null) {
Context.reportRuntimeError(msg,
ee.getSourceName(),
ee.getLineNumber(),
ee.getLineSource(),
ee.getColumnNumber());
} else {
Context.reportRuntimeError(msg);
}
throw new CascadingRuntimeException(ee.getMessage(), ee);
} finally {
updateSession(kScope);
cocoon.invalidate();
Context.exit();
}
}
}
private Throwable unwrap(JavaScriptException e) {
Object value = e.getValue();
while (value instanceof Wrapper) {
value = ((Wrapper)value).unwrap();
}
if (value instanceof Throwable) {
return (Throwable)value;
}
return e;
}
public void forwardTo(Scriptable scope, AO_FOM_Cocoon cocoon,
String uri, Object bizData,
FOM_WebContinuation fom_wk,
Redirector redirector)
throws Exception {
setupView(scope, cocoon, fom_wk);
super.forwardTo(uri, bizData,
fom_wk == null ? null :
fom_wk.getWebContinuation(),
redirector);
}
// package access as this is called by FOM_Cocoon
void process(Scriptable scope, AO_FOM_Cocoon cocoon,
String uri, Object bizData,
OutputStream out)
throws Exception {
setupView(scope, cocoon, null);
super.process(uri, bizData, out);
}
private void setupView(Scriptable scope,
AO_FOM_Cocoon cocoon,
FOM_WebContinuation kont) {
Map objectModel = ContextHelper.getObjectModel(this.avalonContext);
// Make the JS live-connect objects available to the view layer
FOM_JavaScriptFlowHelper.setPackages(objectModel,
(Scriptable)ScriptableObject.getProperty(scope,
"Packages"));
FOM_JavaScriptFlowHelper.setJavaPackage(objectModel,
(Scriptable)ScriptableObject.getProperty(scope,
"java"));
// Make the FOM objects available to the view layer
FOM_JavaScriptFlowHelper.setFOM_Request(objectModel,
cocoon.jsGet_request());
FOM_JavaScriptFlowHelper.setFOM_Response(objectModel,
cocoon.jsGet_response());
Request request = ObjectModelHelper.getRequest(objectModel);
Scriptable session = null;
if (request.getSession(false) != null) {
session = cocoon.jsGet_session();
}
FOM_JavaScriptFlowHelper.setFOM_Session(objectModel, session);
FOM_JavaScriptFlowHelper.setFOM_Context(objectModel,
cocoon.jsGet_context());
if (kont != null) {
FOM_JavaScriptFlowHelper.setFOM_WebContinuation(objectModel,
kont);
}
}
}