All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.infinispan.scripting.impl.ScriptingManagerImpl Maven / Gradle / Ivy
package org.infinispan.scripting.impl;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.BiFunction;
import java.util.function.Function;
import javax.script.Bindings;
import javax.script.Compilable;
import javax.script.CompiledScript;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import javax.script.SimpleBindings;
import org.infinispan.Cache;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.factories.annotations.Inject;
import org.infinispan.factories.annotations.Start;
import org.infinispan.factories.scopes.Scope;
import org.infinispan.factories.scopes.Scopes;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.marshall.core.EncoderRegistry;
import org.infinispan.scripting.ScriptingManager;
import org.infinispan.scripting.logging.Log;
import org.infinispan.scripting.utils.ScriptConversions;
import org.infinispan.security.AuthorizationManager;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.impl.AuthorizationHelper;
import org.infinispan.tasks.TaskContext;
import org.infinispan.tasks.TaskManager;
import org.infinispan.util.logging.LogFactory;
/**
* ScriptingManagerImpl.
*
* @author Tristan Tarrant
* @since 7.2
*/
@Scope(Scopes.GLOBAL)
public class ScriptingManagerImpl implements ScriptingManager {
private static final Log log = LogFactory.getLog(ScriptingManagerImpl.class, Log.class);
@Inject EmbeddedCacheManager cacheManager;
@Inject TaskManager taskManager;
@Inject AuthorizationHelper globalAuthzHelper;
@Inject EncoderRegistry encoderRegistry;
@Inject GlobalConfiguration globalConfiguration;
private ScriptEngineManager scriptEngineManager;
private ConcurrentMap scriptEnginesByExtension = new ConcurrentHashMap<>(2);
private ConcurrentMap scriptEnginesByLanguage = new ConcurrentHashMap<>(2);
private Cache scriptCache;
private ScriptConversions scriptConversions;
ConcurrentMap compiledScripts = new ConcurrentHashMap<>();
private final Function getEngineByName = this::getEngineByName;
private final Function getEngineByExtension = this::getEngineByExtension;
public ScriptingManagerImpl() {
}
@Start
public void start() {
ClassLoader classLoader = globalConfiguration.classLoader();
this.scriptEngineManager = new ScriptEngineManager(classLoader);
taskManager.registerTaskEngine(new ScriptingTaskEngine(this));
scriptConversions = new ScriptConversions(encoderRegistry);
}
Cache getScriptCache() {
if (scriptCache == null) {
scriptCache = SecurityActions.getCache(cacheManager, SCRIPT_CACHE);
}
return scriptCache;
}
ScriptMetadata compileScript(String name, String script) {
ScriptMetadata metadata = ScriptMetadataParser.parse(name, script);
ScriptEngine engine = getEngineForScript(metadata);
if (engine instanceof Compilable) {
try {
CompiledScript compiledScript = ((Compilable) engine).compile(script);
compiledScripts.put(name, compiledScript);
return metadata;
} catch (ScriptException e) {
throw log.scriptCompilationException(e, name);
}
} else {
return null;
}
}
@Override
public void addScript(String name, String script) {
ScriptMetadata metadata = ScriptMetadataParser.parse(name, script);
ScriptEngine engine = getEngineForScript(metadata);
if (engine == null) {
throw log.noScriptEngineForScript(name);
}
getScriptCache().getAdvancedCache().put(name, script, metadata);
}
@Override
public void removeScript(String name) {
if (containsScript(name)) {
getScriptCache().remove(name);
} else {
throw log.noNamedScript(name);
}
}
@Override
public String getScript(String name) {
if (containsScript(name)) {
return SecurityActions.getUnwrappedCache(getScriptCache()).get(name);
} else {
throw log.noNamedScript(name);
}
}
@Override
public Set getScriptNames() {
return SecurityActions.getUnwrappedCache(getScriptCache()).keySet();
}
boolean containsScript(String taskName) {
return SecurityActions.getUnwrappedCache(getScriptCache()).containsKey(taskName);
}
@Override
public CompletableFuture runScript(String scriptName) {
return runScript(scriptName, new TaskContext());
}
@Override
public CompletableFuture runScript(String scriptName, TaskContext context) {
ScriptMetadata metadata = getScriptMetadata(scriptName);
if (globalAuthzHelper != null) {
AuthorizationManager authorizationManager = context.getCache().isPresent() ?
SecurityActions.getAuthorizationManager(context.getCache().get().getAdvancedCache()) : null;
if (authorizationManager != null) {
authorizationManager.checkPermission(AuthorizationPermission.EXEC, metadata.role().orElse(null));
} else {
globalAuthzHelper.checkPermission(AuthorizationPermission.EXEC, metadata.role().orElse(null));
}
}
String scriptMediaType = metadata.dataType().toString();
MediaType requestMediaType = context.getCache().map(c -> c.getAdvancedCache().getValueDataConversion().getRequestMediaType()).orElse(MediaType.MATCH_ALL);
Bindings userBindings = context.getParameters()
.map(p -> {
Map params = scriptConversions.convertParameters(context);
return new SimpleBindings((Map) params);
})
.orElse(new SimpleBindings());
SimpleBindings systemBindings = new SimpleBindings();
DataTypedCacheManager dataTypedCacheManager = new DataTypedCacheManager(scriptMediaType, cacheManager, context.getSubject().orElse(null));
systemBindings.put(SystemBindings.CACHE_MANAGER.toString(), dataTypedCacheManager);
systemBindings.put(SystemBindings.SCRIPTING_MANAGER.toString(), this);
context.getCache().ifPresent(cache -> {
if (requestMediaType != null && !requestMediaType.equals(MediaType.MATCH_ALL)) {
cache = cache.getAdvancedCache().withMediaType(scriptMediaType, scriptMediaType);
}
systemBindings.put(SystemBindings.CACHE.toString(), cache);
});
context.getMarshaller().ifPresent(marshaller -> {
systemBindings.put(SystemBindings.MARSHALLER.toString(), marshaller);
});
CacheScriptBindings bindings = new CacheScriptBindings(systemBindings, userBindings);
ScriptRunner runner = metadata.mode().getRunner();
return runner.runScript(this, metadata, bindings).thenApply(t ->
(T) scriptConversions.convertToRequestType(t, metadata.dataType(), requestMediaType));
}
ScriptMetadata getScriptMetadata(String scriptName) {
CacheEntry scriptEntry = SecurityActions.getCacheEntry(getScriptCache().getAdvancedCache(), scriptName);
if (scriptEntry == null) {
throw log.noNamedScript(scriptName);
}
return (ScriptMetadata) scriptEntry.getMetadata();
}
CompletableFuture execute(ScriptMetadata metadata, Bindings bindings) {
CompiledScript compiled = compiledScripts.get(metadata.name());
try {
if (compiled != null) {
T result = (T) compiled.eval(bindings);
return CompletableFuture.completedFuture(result);
} else {
ScriptEngine engine = getEngineForScript(metadata);
String script = getScriptCache().get(metadata.name());
T result = (T) engine.eval(script, bindings);
return CompletableFuture.completedFuture(result);
}
} catch (ScriptException e) {
throw log.scriptExecutionError(e);
}
}
ScriptEngine getEngineForScript(ScriptMetadata metadata) {
ScriptEngine engine;
if (metadata.language().isPresent()) {
engine = scriptEnginesByLanguage.computeIfAbsent(metadata.language().get(), getEngineByName);
} else {
engine = scriptEnginesByExtension.computeIfAbsent(metadata.extension(), getEngineByExtension);
}
if (engine == null) {
throw log.noEngineForScript(metadata.name());
} else {
return engine;
}
}
private ScriptEngine getEngineByName(String shortName) {
return withClassLoader(ScriptingManagerImpl.class.getClassLoader(),
scriptEngineManager, shortName,
ScriptEngineManager::getEngineByName);
}
private ScriptEngine getEngineByExtension(String extension) {
return withClassLoader(ScriptingManagerImpl.class.getClassLoader(),
scriptEngineManager, extension,
ScriptEngineManager::getEngineByExtension);
}
private static ScriptEngine withClassLoader(ClassLoader cl,
ScriptEngineManager manager, String name,
BiFunction f) {
ClassLoader curr = Thread.currentThread().getContextClassLoader();
try {
Thread.currentThread().setContextClassLoader(cl);
return f.apply(manager, name);
} finally {
Thread.currentThread().setContextClassLoader(curr);
}
}
}
