mishell/src/main/java/org/apache/felix/mishell/JMXEngineContext.java

/*
 *   Copyright 2005 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.felix.mishell;

import java.util.logging.Level;
import java.util.logging.Logger;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineFactory;

/**
 * This class is in charge of most of the interesting stuff. Basically, it keeps the current engine instance being used
 * and creates the OSGiScriptEngineManager 'decorator' that handles the fact that engines can be installed in 
 * separate bundles and then the mechanism for finding engines used by the javax.script API does not work.
 *
 */
public class JMXEngineContext {
	private ScriptEngine engine;
	private OSGiScriptEngineManager engineManager;
	private String language;

	Logger log=Logger.getLogger(JMXEngineContext.class.getName());
	Level l=Level.INFO;
	public JMXEngineContext(String language) throws EngineNotFoundException{
		this(language, null);
	}
	public JMXEngineContext(String lang, OSGiScriptEngineManager engineManager)throws EngineNotFoundException{
		this.engineManager=engineManager;
		if (log.isLoggable(l)){
		StringBuffer msg=new StringBuffer("Available script engines are:");
		log.log(l, "Available script engines are: \n");
		for (ScriptEngineFactory sef : engineManager.getEngineFactories()) {
			msg.append(sef.getEngineName()+"\n");
		}
		log.log(l, msg.toString());
		}
		JMoodProxyManager manager=new JMoodProxyManager();
		engine=engineManager.getEngineByName(lang);
		this.language=engine.getFactory().getLanguageName();
		String managerName=getVarName("manager");
		engineManager.put(managerName, manager);
		for(String key: engineManager.getBindings().keySet()){
			engine.put(getVarName(key), engineManager.get(key));
			}
		
		if (engine==null) throw new EngineNotFoundException(language);
	}
	/**
	 * This method is used because prior versions of jrbuy binding needed global variables
	 * to be called '$'+name. Last version already do that automatically, so this is not needed anymore
	 * @param name
	 * @return
	 */
	//TODO: remove this method when we update to latest version of jruby-engine
	private String getVarName(String name){
		if (engine.getFactory().getEngineName().equals("jruby")) name="$"+name;
		return name;
		
	}
	public ScriptEngine getEngine() {
		return engine;
	}
	public void setEngine(ScriptEngine engine) {
		this.engine = engine;
	}
	public OSGiScriptEngineManager getEngineManager() {
		return engineManager;
	}
	public void setEngineManager(OSGiScriptEngineManager engineManager) {
		this.engineManager = engineManager;
	}
	/**
	 * This methods changes the engine language. It reloads the ScriptEngineManagers to ensure
	 * that any new engines (for example new bundles or updated ones) are discovered.  
	 * @param name
	 * @throws EngineNotFoundException
	 */
	public void setLanguage(String name) throws EngineNotFoundException{
		OSGiScriptEngineManager manager=(OSGiScriptEngineManager)engineManager;
		manager.reloadManagers();
		ScriptEngine newEngine=manager.getEngineByName(name);
		if(newEngine!=null) {
			engine=newEngine;
			language=engine.getFactory().getLanguageName();
			for(String key: engineManager.getBindings().keySet()){
				System.out.println(key);
				engine.put(getVarName(key), engineManager.get(key));
				}

		}
		else throw new EngineNotFoundException("name");
	}
	public String getLanguage(){
		return language;
	}
}