mishell/src/test/java/org/apache/felix/mishell/OSGiScriptEngineFinder.java

package org.apache.felix.mishell;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineFactory;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;

public class OSGiScriptEngineFinder {
	private BundleContext context;

	public OSGiScriptEngineFinder(BundleContext context) {
		this.context = context;
	}
	private List<String> getAllEngineFactoryCandidates() throws IOException{
		Bundle[] bundles = context.getBundles();
		List<String> factoryCandidates = new ArrayList<String>();
		for (Bundle bundle : bundles) {
			System.out.println(bundle.getSymbolicName());
			if(bundle.getSymbolicName().equals("system.bundle")) continue;
			Enumeration urls = bundle.findEntries("META-INF/services",
					"javax.script.ScriptEngineFactory", false);
			if (urls == null)
				continue;
			while (urls.hasMoreElements()) {
				URL u = (URL) urls.nextElement();
				BufferedReader reader = new BufferedReader(
						new InputStreamReader(u.openStream()));
				String line;
				while ((line = reader.readLine()) != null) {
					factoryCandidates.add(line.trim());
					//Just for testing:
					
					try {
						Class engineFactory=Class.forName(line.trim());
						ScriptEngineManager manager=new ScriptEngineManager(engineFactory.getClassLoader());
						for (ScriptEngineFactory f: manager.getEngineFactories()){
							ClassLoader old=Thread.currentThread().getContextClassLoader();
							Thread.currentThread().setContextClassLoader(engineFactory.getClassLoader());
							ScriptEngine e=f.getScriptEngine();//.eval(f.getOutputStatement("Hello world"));
							Thread.currentThread().setContextClassLoader(old);
							e.eval("File.new(\"\")");
							Thread.currentThread().sleep(1000);
						}
					} catch (ClassNotFoundException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
						catch (ScriptException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
 catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
				}
			}
		}
		return factoryCandidates;
	}
	public ScriptEngineManager getManagerFor(String factoryName) throws ClassNotFoundException{
		Class factory=Class.forName(factoryName); 
		String a;
		ScriptEngineManager manager=new ScriptEngineManager(factory.getClassLoader());
		//Does this manager know the factory?
		boolean flag=false;
		for (ScriptEngineFactory fac : manager.getEngineFactories()){
			if(fac.getClass().equals(factory)) flag=true;
		}
		return manager;
		
	}
	/**
	 * Adds Engine factories found in installed bundles. The resolution order is the following:
	 * <ol>
	 * <li>First, all the factories found by the manager are used. This includes all factories seen by 
	 * the class loader that instantiated the ScriptEngineManager
	 * </li>
	 * <li>Then, by order of installation, the rest of the bundles are seeked. Therefore, if an engine appears in
	 * two bundles, only the first one is used. 
	 * </li>
	 * </ol>
	 * This should not be a problem, as this method is intended for sparse use (only when changing the language)
	 * @param the manager to whom the factories are going to be added
	 * @exception RuntimeException wrapper for IOException in case there is any problem with the bundle.findEntries methods
	 * @exception RuntimeException  wrapper for ClassNotFoundException and InstantiationException which are supposed not to happen
	 */
	public void addEngineFactories(ScriptEngineManager manager){
		//TODO refactor all this to make it work. An option is to directly use 
		System.out.println("calling add engine factories");
		try{
		List<String> factoryCandidates=this.getAllEngineFactoryCandidates();
		for (String candidate: factoryCandidates){
			System.out.println("Candidate: "+candidate);
			Class factoryClazz=this.getClass().getClassLoader().loadClass(candidate);
			ScriptEngineFactory factory=(ScriptEngineFactory) factoryClazz.newInstance();
			ScriptEngine engine=factory.getScriptEngine();
			try {
				engine.eval("puts 'Hello world'");
			} catch (ScriptException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			if(manager.getEngineByName(factory.getLanguageName())!=null){
				System.out.println("Engine already existing. Continuing");
				continue; //This means that there already is a factory for that language
			}
			//Now we register the factory for all its names, extensions and mime types
			for(String name: factory.getNames()){
				System.out.println("registering "+name);
				manager.registerEngineName(name, factory);
			}
			for (String type: factory.getMimeTypes()){
				manager.registerEngineMimeType(type, factory);
				System.out.println(manager.getEngineByMimeType(type).equals(factory));
			}
			for (String extension: factory.getExtensions()){
				manager.registerEngineExtension(extension, factory);
				System.out.println(manager.getEngineByExtension(extension).equals(factory));

			}
			}
		System.out.println("manager now has: ");
		System.out.println(manager.getEngineByName("jruby"));
		
		for (ScriptEngineFactory f : manager.getEngineFactories()){
			System.out.println(f);
		}
		}catch (IOException ioe){
			throw new RuntimeException(ioe); 
		} catch (ClassNotFoundException cnfe) {
		} catch (InstantiationException iee) {
			throw new RuntimeException (iee);
		} catch (IllegalAccessException iae) {
			throw new RuntimeException(iae); 
		}
	}
}