/*
* Copyright 2004,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.bsf.engines.java;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.lang.reflect.Method;
import java.util.Hashtable;
import java.util.Vector;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
import org.apache.bsf.util.BSFEngineImpl;
import org.apache.bsf.util.CodeBuffer;
import org.apache.bsf.util.EngineUtils;
import org.apache.bsf.util.JavaUtils;
import org.apache.bsf.util.MethodUtils;
import org.apache.bsf.util.ObjInfo;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* This is the interface to Java from the
* Bean Scripting Framework.
* <p>
* The Java code must be written script-style -- that is, just the body of
* the function, without class or method headers or footers.
* The JavaEngine will generate those via a "boilerplate" wrapper:
* <pre>
* <code>
* import java.lang.*;
* import java.util.*;
* public class $$CLASSNAME$$ {
* static public Object BSFJavaEngineEntry(org.apache.bsf.BSFManager bsf) {
* // Your code will be placed here
* }
* }
* </code>
* </pre>
* $$CLASSNAME$$ will be replaced by a generated classname of the form
* BSFJava*, and the bsf parameter can be used to retrieve application
* objects registered with the Bean Scripting Framework.
* <p>
* If you use the placeholder string $$CLASSNAME$$ elsewhere
* in your script -- including within text strings -- BSFJavaEngine will
* replace it with the generated name of the class before the Java code
* is compiled.
* <p>
* <h2>Hazards:</h2>
* <p>
* NOTE that it is your responsibility to convert the code into an acceptable
* Java string. If you're invoking the JavaEngine directly (as in the
* JSPLikeInJava example) that means \"quoting\" characters that would
* otherwise cause trouble.
* <p>
* ALSO NOTE that it is your responsibility to return an object, or null in
* lieu thereof!
* <p>
* Since the code has to be compiled to a Java classfile, invoking it involves
* a fair amount of computation to load and execute the compiler. We are
* currently making an attempt to manage that by caching the class
* after it has been loaded, but the indexing is fairly primitive. It has
* been suggested that the Bean Scripting Framework may want to support
* preload-and-name-script and execute-preloaded-script-by-name options to
* provide better control over when and how much overhead occurs.
* <p>
* @author Joe Kesselman
*/
public class JavaEngine extends BSFEngineImpl {
Class javaclass = null;
static Hashtable codeToClass = new Hashtable();
static String serializeCompilation = "";
static String placeholder = "$$CLASSNAME$$";
String minorPrefix;
private Log logger = LogFactory.getLog(this.getClass().getName());
/**
* Create a scratchfile, open it for writing, return its name.
* Relies on the filesystem to provide us with uniqueness testing.
* NOTE THAT uniqueFileOffset continues to count; we don't want to
* risk reusing a classname we have previously loaded in this session
* even if the classfile has been deleted.
*/
private int uniqueFileOffset = -1;
private class GeneratedFile {
File file = null;
FileOutputStream fos = null;
String className = null;
GeneratedFile(File file, FileOutputStream fos, String className) {
this.file = file;
this.fos = fos;
this.className = className;
}
}
/**
* Constructor.
*/
public JavaEngine () {
// Do compilation-possible check here??????????????
}
public Object call (Object object, String method, Object[] args)
throws BSFException
{
throw new BSFException (BSFException.REASON_UNSUPPORTED_FEATURE,
"call() is not currently supported by JavaEngine");
}
public void compileScript (String source, int lineNo, int columnNo,
Object script, CodeBuffer cb) throws BSFException {
ObjInfo oldRet = cb.getFinalServiceMethodStatement ();
if (oldRet != null && oldRet.isExecutable ()) {
cb.addServiceMethodStatement (oldRet.objName + ";");
}
cb.addServiceMethodStatement (script.toString ());
cb.setFinalServiceMethodStatement (null);
}
/**
* This is used by an application to evaluate a string containing
* some expression. It should store the "bsf" handle where the
* script can get to it, for callback purposes.
* <p>
* Note that Java compilation imposes serious overhead,
* but in exchange you get full Java performance
* once the classes have been created (minus the cache lookup cost).
* <p>
* Nobody knows whether javac is threadsafe.
* I'm going to serialize access to protect it.
* <p>
* There is no published API for invoking javac as a class. There's a trick
* that seems to work for Java 1.1.x, but it stopped working in Java 1.2.
* We will attempt to use it, then if necessary fall back on invoking
* javac via the command line.
*/
public Object eval (String source, int lineNo, int columnNo,
Object oscript) throws BSFException
{
Object retval = null;
String classname = null;
GeneratedFile gf = null;
String basescript = oscript.toString();
String script = basescript; // May be altered by $$CLASSNAME$$ expansion
try {
// Do we already have a class exactly matching this code?
javaclass = (Class)codeToClass.get(basescript);
if(javaclass != null) {
classname=javaclass.getName();
} else {
gf = openUniqueFile(tempDir, "BSFJava",".java");
if( gf == null) {
throw new BSFException("couldn't create JavaEngine scratchfile");
}
// Obtain classname
classname = gf.className;
// Write the kluge header to the file.
gf.fos.write(("import java.lang.*;"+
"import java.util.*;"+
"public class "+classname+" {\n" +
" static public Object BSFJavaEngineEntry(org.apache.bsf.BSFManager bsf) {\n")
.getBytes());
// Edit the script to replace placeholder with the generated
// classname. Note that this occurs _after_ the cache was checked!
int startpoint = script.indexOf(placeholder);
int endpoint;
if(startpoint >= 0) {
StringBuffer changed = new StringBuffer();
for(; startpoint >=0; startpoint = script.indexOf(placeholder,startpoint)) {
changed.setLength(0); // Reset for 2nd pass or later
if(startpoint > 0) {
changed.append(script.substring(0,startpoint));
}
changed.append(classname);
endpoint = startpoint+placeholder.length();
if(endpoint < script.length()) {
changed.append(script.substring(endpoint));
}
script = changed.toString();
}
}
// MJD - debug
// BSFDeclaredBean tempBean;
// String className;
//
// for (int i = 0; i < declaredBeans.size (); i++) {
// tempBean = (BSFDeclaredBean) declaredBeans.elementAt (i);
// className = StringUtils.getClassName (tempBean.bean.getClass ());
//
// gf.fos.write ((className + " " +
// tempBean.name + " = (" + className +
// ")bsf.lookupBean(\"" +
// tempBean.name + "\");").getBytes ());
// }
// MJD - debug
// Copy the input to the file.
// Assumes all available -- probably mistake, but same as other engines.
gf.fos.write(script.getBytes());
// Close the method and class
gf.fos.write(("\n }\n}\n").getBytes());
gf.fos.close();
// Compile through Java to .class file
// May not be threadsafe. Serialize access on static object:
synchronized(serializeCompilation) {
JavaUtils.JDKcompile(gf.file.getPath(), classPath);
}
// Load class.
javaclass = EngineUtils.loadClass(mgr, classname);
// Stash class for reuse
codeToClass.put(basescript, javaclass);
}
Object[] callArgs = {mgr};
retval = internalCall(this,"BSFJavaEngineEntry",callArgs);
}
catch(Exception e) {
e.printStackTrace ();
throw new BSFException (BSFException.REASON_IO_ERROR, e.getMessage ());
} finally {
// Cleanup: delete the .java and .class files
// if(gf!=null && gf.file!=null && gf.file.exists())
// gf.file.delete(); // .java file
if(classname!=null) {
// Generated class
File file = new File(tempDir+File.separatorChar+classname+".class");
// if(file.exists())
// file.delete();
// Search for and clean up minor classes, classname$xxx.class
file = new File(tempDir); // ***** Is this required?
minorPrefix = classname+"$"; // Indirect arg to filter
String[] minorClassfiles = file.list(new FilenameFilter()
{
// Starts with classname$ and ends with .class
public boolean accept(File dir,String name) {
return
(0 == name.indexOf(minorPrefix))
&&
(name.lastIndexOf(".class") == name.length()-6);
}
});
for(int i = 0; i < minorClassfiles.length; ++i) {
file = new File(minorClassfiles[i]);
// file.delete();
}
}
}
return retval;
}
public void initialize (BSFManager mgr, String lang,
Vector declaredBeans) throws BSFException {
super.initialize (mgr, lang, declaredBeans);
}
/**
* Return an object from an extension.
* @param object Object on which to make the internal_call (ignored).
* @param method The name of the method to internal_call.
* @param args an array of arguments to be
* passed to the extension, which may be either
* Vectors of Nodes, or Strings.
*/
Object internalCall (Object object, String method, Object[] args)
throws BSFException
{
//***** ISSUE: Only static methods are currently supported
Object retval = null;
try {
if(javaclass != null) {
//***** This should call the lookup used in BML, for typesafety
Class[] argtypes = new Class[args.length];
for(int i=0; i<args.length; ++i) {
argtypes[i]=args[i].getClass();
}
Method m = MethodUtils.getMethod(javaclass, method, argtypes);
retval = m.invoke(null, args);
}
}
catch(Exception e) {
throw new BSFException (BSFException.REASON_IO_ERROR, e.getMessage ());
}
return retval;
}
private GeneratedFile openUniqueFile(String directory,String prefix,String suffix) {
File file = null;
FileOutputStream fos = null;
int max = 1000; // Don't try forever
GeneratedFile gf = null;
int i;
String className = null;
for(i=max,++uniqueFileOffset; fos==null && i>0;--i,++uniqueFileOffset) {
// Probably a timing hazard here... ***************
try {
className = prefix+uniqueFileOffset;
file = new File(directory+File.separatorChar+className+suffix);
if(file != null && !file.exists()) {
fos = new FileOutputStream(file);
}
}
catch(Exception e) {
// File could not be opened for write, or Security Exception
// was thrown. If someone else created the file before we could
// open it, that's probably a threading conflict and we don't
// bother reporting it.
if(!file.exists()) {
logger.error("openUniqueFile: unexpected ", e);
}
}
}
if(fos==null) {
logger.error("openUniqueFile: Failed "+max+"attempts.");
} else {
gf = new GeneratedFile(file,fos,className);
}
return gf;
}
}