/*
* 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.netrexx;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.PrintWriter;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Hashtable;
import java.util.Vector;
import org.apache.bsf.BSFDeclaredBean;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
import org.apache.bsf.util.BSFEngineImpl;
import org.apache.bsf.util.BSFFunctions;
import org.apache.bsf.util.EngineUtils;
import org.apache.bsf.util.MethodUtils;
import org.apache.bsf.util.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* This is the interface to NetRexx from the
* Bean Scripting Framework.
* <p>
* The NetRexx code must be written script-style, without a "class" or
* "properties" section preceeding the executable code. The NetRexxEngine will
* generate a prefix for this code:
* <pre>
* <code>
* class $$CLASSNAME$$;
* method BSFNetRexxEngineEntry(bsf=org.apache.bsf.BSFManager) public static;
* </code>
* </pre>
* $$CLASSNAME$$ will be replaced by a generated classname of the form
* BSFNetRexx*, 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 -- BSFNetRexxEngine will
* replace it with the generated name of the class before the NetRexx code
* is compiled.
* <p>
* If you need to use full NetRexx functionality, we recommend that your
* NetRexx script define and invoke a "minor class", with or without the
* "dependent" keyword as suits your needs. You'll have to use $$CLASSNAME$$
* in naming the minor class, since the name of the main class is synthesized;
* for example, to create the minor class "bar" you'd write
* "class $$CLASSNAME$$.Bar".
* <p>
* <h2>Hazards:</h2>
* <p>
* Since NetRexx 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; we
* hash against the script string to find the class for it.
* <p>
* Minor-class .class files are now being deleted after the major class loads.
* This coould potentially cause problems.
*
* @author Joe Kesselman
* @author Sanjiva Weerawarana
*/
public class NetRexxEngine extends BSFEngineImpl
{
BSFFunctions mgrfuncs;
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.
*
* I've made the offset static, due to concerns about reuse/reentrancy
* of the NetRexx engine.
*/
private static int uniqueFileOffset=0;
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;
}
}
// rexxclass used to be an instance variable, on the theory that
// each NetRexxEngine was an instance of a specific script.
// BSF is currently reusing Engines, so caching the class
// no longer makes sense.
// Class rexxclass;
/**
* Constructor.
*/
public NetRexxEngine ()
{
/*
The following line is intended to cause the constructor to
throw a NoClassDefFoundError if the NetRexxC.zip dependency
is not resolved.
If this line was not here, the problem would not surface until
the actual processing of a script. We want to know all is well
at the time the engine is instantiated, not when we attempt to
process a script.
*/
new netrexx.lang.BadArgumentException();
}
/**
* Return an object from an extension.
* @param object object from which to call our static method
* @param method The name of the method to call.
* @param args an array of arguments to be
* passed to the extension, which may be either
* Vectors of Nodes, or Strings.
*/
public Object call (Object object, String method, Object[] args)
throws BSFException
{
throw new BSFException(BSFException.REASON_UNSUPPORTED_FEATURE,
"NetRexx doesn't currently support call()",
null);
}
/**
* Invoke a static method.
* @param rexxclass Class to invoke the method against
* @param method The name of the method to call.
* @param args an array of arguments to be
* passed to the extension, which may be either
* Vectors of Nodes, or Strings.
*/
Object callStatic(Class rexxclass, String method, Object[] args)
throws BSFException
{
//***** ISSUE: Currently supports only static methods
Object retval = null;
try
{
if (rexxclass != 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(rexxclass, method, argtypes);
retval=m.invoke(null,args);
}
else
{
logger.error("NetRexxEngine: ERROR: rexxclass==null!");
}
}
catch(Exception e)
{
e.printStackTrace ();
if (e instanceof InvocationTargetException)
{
Throwable t = ((InvocationTargetException)e).getTargetException ();
t.printStackTrace ();
}
throw new BSFException (BSFException.REASON_IO_ERROR,
e.getMessage (),
e);
}
return retval;
}
public void declareBean (BSFDeclaredBean bean) throws BSFException {}
/**
* Override impl of execute. In NetRexx, methods which do not wish
* to return a value should be invoked via exec, which will cause them
* to be generated without the "returns" clause.
* Those which wish to return a value should call eval instead.
* which will add "returns java.lang.Object" to the header.
*
* Note: It would be nice to have the "real" return type avaialable, so
* we could do something more type-safe than Object, and so we could
* return primitive types without having to enclose them in their
* object wrappers. BSF does not currently support that concept.
*/
public Object eval (String source, int lineNo, int columnNo,
Object script)
throws BSFException
{
return execEvalShared(source, lineNo, columnNo, script,true);
}
/**
* Override impl of execute. In NetRexx, methods which do not wish
* to return a value should be invoked via exec, which will cause them
* to be generated without the "returns" clause.
* Those which wish to return a value should call eval instead.
* which will add "returns java.lang.Object" to the header.
*/
public void exec (String source, int lineNo, int columnNo,
Object script)
throws BSFException
{
execEvalShared(source, lineNo, columnNo, script,false);
}
/**
* This is shared code for the exec() and eval() operations. It will
* evaluate a string containing a NetRexx method body -- which may be
* as simple as a single return statement.
* It should store the "bsf" handle where the
* script can get to it, for callback purposes.
* <p>
* Note that NetRexx compilation imposes serious overhead -- 11 seconds for
* the first compile, about 3 thereafter -- but in exchange you get
* Java-like speeds 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 the compilers to protect it.
*/
public Object execEvalShared (String source, int lineNo, int columnNo,
Object oscript,boolean returnsObject)
throws BSFException
{
Object retval=null;
String classname=null;
GeneratedFile gf=null;
// Moved into the exec process; see comment above.
Class rexxclass=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?
rexxclass=(Class)codeToClass.get(basescript);
if(rexxclass!=null)
{
logger.debug("NetRexxEngine: Found pre-compiled class" +
" for script '" + basescript + "'");
classname=rexxclass.getName();
}
else
{
gf=openUniqueFile(tempDir,"BSFNetRexx",".nrx");
if(gf==null)
throw new BSFException("couldn't create NetRexx scratchfile");
// Obtain classname
classname=gf.className;
// Decide whether to declare a return type
String returnsDecl="";
if(returnsObject)
returnsDecl="returns java.lang.Object";
// Write the kluge header to the file.
// ***** By doing so we give up the ability to use Property blocks.
gf.fos.write(("class "+classname+";\n")
.getBytes());
gf.fos.write(
("method BSFNetRexxEngineEntry(bsf=org.apache.bsf.util.BSFFunctions) "+
" public static "+returnsDecl+";\n")
.getBytes());
// Edit the script to replace placeholder with the generated
// classname. Note that this occurs _after_ the cache was
// checked!
int startpoint,endpoint;
if((startpoint=script.indexOf(placeholder))>=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();
}
}
BSFDeclaredBean tempBean;
String className;
for (int i = 0; i < declaredBeans.size (); i++)
{
tempBean = (BSFDeclaredBean) declaredBeans.elementAt (i);
className = StringUtils.getClassName (tempBean.type);
gf.fos.write ((tempBean.name + " =" + className + " bsf.lookupBean(\"" +
tempBean.name + "\");").getBytes());
}
if(returnsObject)
gf.fos.write("return ".getBytes());
// Copy the input to the file.
// Assumes all available -- probably mistake, but same as
// other engines.
gf.fos.write(script.getBytes());
gf.fos.close();
logger.debug("NetRexxEngine: wrote temp file " +
gf.file.getPath () + ", now compiling");
// Compile through Java to .class file
String command=gf.file.getPath(); //classname;
if (logger.isDebugEnabled()) {
command += " -verbose4";
} else {
command += " -noverbose";
command += " -noconsole";
}
netrexx.lang.Rexx cmdline= new netrexx.lang.Rexx(command);
int retValue;
// May not be threadsafe. Serialize access on static object:
synchronized(serializeCompilation)
{
// compile to a .java file
retValue =
COM.ibm.netrexx.process.NetRexxC.main(cmdline,
new PrintWriter(System.err));
}
// Check if there were errors while compiling the Rexx code.
if (retValue == 2)
{
throw new BSFException(BSFException.REASON_EXECUTION_ERROR,
"There were NetRexx errors.");
}
// Load class.
logger.debug("NetRexxEngine: loading class "+classname);
rexxclass=EngineUtils.loadClass (mgr, classname);
// Stash class for reuse
codeToClass.put(basescript,rexxclass);
}
Object[] args={mgrfuncs};
retval=callStatic(rexxclass, "BSFNetRexxEngineEntry",args);
}
catch (BSFException e)
{
// Just forward the exception on.
throw e;
}
catch(Exception e)
{
e.printStackTrace ();
if (e instanceof InvocationTargetException)
{
Throwable t = ((InvocationTargetException)e).getTargetException ();
t.printStackTrace ();
}
throw new BSFException (BSFException.REASON_IO_ERROR,
e.getMessage (), e);
}
finally
{
// Cleanup: delete the .nrx and .class files
// (if any) generated by NetRexx Trace requests.
if(gf!=null && gf.file!=null && gf.file.exists())
gf.file.delete(); // .nrx file
if(classname!=null)
{
// Generated src
File file=new File(tempDir+File.separatorChar+classname+".java");
if(file.exists())
file.delete();
// Generated class
file=new File(classname+".class");
if(file.exists())
file.delete();
// Can this be done without disrupting trace?
file=new File(tempDir+File.separatorChar+classname+".crossref");
if(file.exists())
file.delete();
// Search for and clean up minor classes, classname$xxx.class
file=new File(tempDir);
minorPrefix=classname+"$"; // Indirect arg to filter
String[] minor_classfiles=
file.list(
// ANONYMOUS CLASS for filter:
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)
;
}
}
);
if(minor_classfiles!=null)
for(int i=minor_classfiles.length;i>0;)
{
file=new File(minor_classfiles[--i]);
file.delete();
}
}
}
return retval;
}
public void initialize(BSFManager mgr, String lang,Vector declaredBeans)
throws BSFException
{
super.initialize(mgr, lang, declaredBeans);
mgrfuncs = new BSFFunctions (mgr, this);
}
private GeneratedFile openUniqueFile(String directory,String prefix,String suffix)
{
File file=null,obj=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);
obj=new File(directory+File.separatorChar+className+".class");
if(file!=null && !file.exists() & obj!=null & !obj.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;
}
public void undeclareBean (BSFDeclaredBean bean) throws BSFException {}
}