/*
* Copyright (C) 2009 eXo Platform SAS.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.exoplatform.services.script.groovy;
import groovy.lang.GroovyClassLoader;
import groovy.lang.GroovyCodeSource;
import org.codehaus.groovy.control.CompilationFailedException;
import org.exoplatform.commons.utils.SecurityHelper;
import org.exoplatform.container.ExoContainer;
import org.exoplatform.container.ExoContainerContext;
import org.exoplatform.container.component.ComponentPlugin;
import org.exoplatform.services.log.ExoLogger;
import org.exoplatform.services.log.Log;
import org.exoplatform.services.script.groovy.jarjar.JarJarClassLoader;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author <a href="mailto:andrew00x@gmail.com">Andrey Parfonov</a>
* @version $Id: $
*/
public class GroovyScriptInstantiator
{
/** Our logger. */
private static final Log LOG = ExoLogger.getLogger(GroovyScriptInstantiator.class);
/**
* eXo Container.
*/
private ExoContainer container;
/** The global mapping. */
private Map<String, String> mapping;
/**
* @param containerContext container context
*/
public GroovyScriptInstantiator(ExoContainerContext containerContext)
{
this.container = containerContext.getContainer();
this.mapping = Collections.synchronizedMap(new HashMap<String, String>());
}
/**
* Load script from given address.
*
* @param spec the resource's address.
* @return the object created from groovy script.
* @throws MalformedURLException if parameter <code>url</code> have wrong
* format.
* @throws IOException if can't load script from given <code>url</code>.
* @see GroovyScriptInstantiator#instantiateScript(URL)
* @see GroovyScriptInstantiator#instantiateScript(InputStream)
*/
public Object instantiateScript(String spec) throws MalformedURLException, IOException
{
return instantiateScript(new URL(spec));
}
/**
* Load script from given address.
*
* @param url the resource's address.
* @return the object created from groovy script.
* @throws IOException if can't load script from given <code>url</code>.
* @see GroovyScriptInstantiator#instantiateScript(InputStream)
*/
public Object instantiateScript(URL url) throws IOException
{
String name = url.toString();
return instantiateScript(new BufferedInputStream(url.openStream()), name);
}
/**
* Parse given stream, the stream must represents groovy script.
*
* @param stream the stream represented groovy script.
* @return the object created from groovy script.
* @throws IOException if stream can't be parsed or object can't be created
* cause to illegal content of stream
*/
public Object instantiateScript(InputStream stream) throws IOException
{
return instantiateScript(stream, null);
}
/**
* Parse given stream, the stream must represents groovy script.
*
* @param stream the stream represented groovy script.
* @param name script name is null or empty string that groovy completer will
* use default name
* @return the object created from groovy script.
* @throws IOException if stream can't be parsed or object can't be created
* cause to illegal content of stream
*/
public Object instantiateScript(InputStream stream, String name) throws IOException
{
GroovyClassLoader loader;
if (mapping.size() > 0)
{
JarJarClassLoader jarjarLoader = SecurityHelper.doPrivilegedAction(new PrivilegedAction<JarJarClassLoader>()
{
public JarJarClassLoader run()
{
return new JarJarClassLoader();
}
});
jarjarLoader.addMapping(mapping);
loader = jarjarLoader;
}
else
{
loader = SecurityHelper.doPrivilegedAction(new PrivilegedAction<GroovyClassLoader>()
{
public GroovyClassLoader run()
{
return new GroovyClassLoader();
}
});
}
return instantiateScript(stream, name, loader);
}
/**
* Parse given stream, the stream must represents groovy script and use given
* class-loader. If <code>loader == null</code> then
* {@link groovy.lang.GroovyClassLoader} will be is use.
*
* @param stream the stream represented groovy script.
* @param name script name is null or empty string that groovy completer will
* use default name
* @param loader GroovyClassLoader or <code>null</code>
* @return the object created from groovy script.
* @throws IOException if stream can't be parsed or object can't be created
* cause to illegal content of stream
*/
public Object instantiateScript(final InputStream stream, final String name, GroovyClassLoader loader)
throws IOException
{
if (loader == null)
{
loader = new GroovyClassLoader();
}
Class<?> clazz = null;
try
{
final GroovyClassLoader fLoader = loader;
clazz = SecurityHelper.doPrivilegedExceptionAction(new PrivilegedExceptionAction<Class<?>>()
{
public Class<?> run() throws Exception
{
if (name != null && name.length() > 0)
{
return fLoader.parseClass(stream, name);
}
else
{
return fLoader.parseClass(stream);
}
}
});
}
catch (PrivilegedActionException pae)
{
Throwable cause = pae.getCause();
if (cause instanceof CompilationFailedException)
{
throw new IOException("Error occurs when parse stream, compiler error:\n " + cause.getMessage(), cause);
}
else if (cause instanceof RuntimeException)
{
throw (RuntimeException)cause;
}
else
{
throw new RuntimeException(cause);
}
}
try
{
return createObject(clazz);
}
catch (Exception e)
{
throw new RuntimeException("Can't instantiate groovy script: " + e.getMessage(), e);
}
finally
{
stream.close();
}
}
/**
* Instantiate script from give {@link GroovyCodeSource} and use given
* class-loader. If <code>loader == null</code> then
* {@link groovy.lang.GroovyClassLoader} will be is use.
*
* @param codeSource code source
* @param loader
* @return
*/
public Object instantiateScript(final GroovyCodeSource codeSource, GroovyClassLoader loader)
{
if (loader == null)
{
loader = new GroovyClassLoader();
}
final GroovyClassLoader fLoader = loader;
Class<?> clazz = SecurityHelper.doPrivilegedAction(new PrivilegedAction<Class<?>>()
{
public Class<?> run()
{
return fLoader.parseClass(codeSource);
}
});
try
{
return createObject(clazz);
}
catch (Exception e)
{
throw new RuntimeException("Can't instantiate groovy script: " + e.getMessage(), e);
}
}
/**
* Created object from given class, if class has parameters in constructor,
* then this parameters will be searched in container.
*
* @param clazz java-groovy class
*/
private Object createObject(Class<?> clazz) throws Exception
{
Constructor<?>[] constructors = clazz.getConstructors();
/*
* Sort constructors by number of parameters. With more parameters must be
* first.
*/
Arrays.sort(constructors, COMPARATOR);
l : for (Constructor<?> c : constructors)
{
Class<?>[] parameterTypes = c.getParameterTypes();
if (parameterTypes.length == 0)
{
return c.newInstance();
}
List<Object> parameters = new ArrayList<Object>(parameterTypes.length);
for (Class<?> parameterType : parameterTypes)
{
Object param = container.getComponentInstanceOfType(parameterType);
if (param == null)
{
continue l;
}
parameters.add(param);
}
return c.newInstance(parameters.toArray(new Object[parameters.size()]));
}
return null;
}
private static final ConstructorsComparator COMPARATOR = new ConstructorsComparator();
/**
* Sorts array of constructors by number of parameters.
*/
private static class ConstructorsComparator implements Comparator<Constructor<?>>
{
/**
* {@inheritDoc}
*/
public int compare(Constructor<?> constructor1, Constructor<?> constructor2)
{
int c1 = constructor1.getParameterTypes().length;
int c2 = constructor2.getParameterTypes().length;
if (c1 < c2)
{
return 1;
}
if (c1 > c2)
{
return -1;
}
return 0;
}
}
public void addPlugin(ComponentPlugin plugin)
{
if (plugin instanceof GroovyScriptJarJarPlugin)
{
GroovyScriptJarJarPlugin jarjarPlugin = (GroovyScriptJarJarPlugin)plugin;
if (LOG.isDebugEnabled())
{
LOG.debug("Add mapping to groovy instantiator:" + jarjarPlugin.getMapping());
}
mapping.putAll(jarjarPlugin.getMapping());
}
}
}