private Class<?> lookIntoProcessClassLoader(final ProcessDefinitionUUID processUUID, final String className) { final ClassLoader classLoader = getProcessClassLoader(processUUID); try { final Class<?> result = classLoader.loadClass(className); if (result != null && result.getClassLoader().equals(classLoader)) { return result; } } catch (final Throwable e) { return null; } return null; }
@Override protected ClassLoader getClassLoader() { return EnvTool.getClassDataLoader().getProcessClassLoader(processUUID); }
@Override protected ClassLoader getClassLoader(final ProcessDefinitionUUID processUUID) { return EnvTool.getClassDataLoader().getProcessClassLoader(processUUID); }
private void processInstantiateProcessMethod(final Object[] args) { final ClassLoader localClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader( (ProcessDefinitionUUID) args[0]); Thread.currentThread().setContextClassLoader(localClassLoader); args[1] = ((RESTMap<?, ?>) args[1]).getActualMap(); }
private Object getObjectFromXML(final String xmlRepresentation, final ProcessDefinitionUUID processUUID) { final XStream xstream = XStreamUtil.getDefaultXstream(); Object result = null; ClassLoader localClassLoader = null; try { result = xstream.fromXML(xmlRepresentation); } catch (final Exception e) { // try with ProcessClassLoader localClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(processUUID); Thread.currentThread().setContextClassLoader(localClassLoader); try { result = xstream.fromXML(xmlRepresentation); } catch (final Exception ex) { // try with CommonClassLoader localClassLoader = EnvTool.getClassDataLoader().getCommonClassLoader(); Thread.currentThread().setContextClassLoader(localClassLoader); result = xstream.fromXML(xmlRepresentation); } } return result; }
@Override public byte[] getResource(final ProcessDefinitionUUID definitionUUID, final String resourcePath) throws ProcessNotFoundException { getInternalProcess(definitionUUID); final ClassLoader classLoader = EnvTool.getClassDataLoader().getProcessClassLoader(definitionUUID); final InputStream in = classLoader.getResourceAsStream(resourcePath); byte[] resource = null; if (in != null) { try { resource = Misc.getAllContentFrom(in); in.close(); } catch (final IOException e) { } } return resource; }
public Map<String, Object> execute(final ClassLoader classLoader, final ProcessDefinitionUUID definitionUUID) throws Exception { final ClassLoader baseClassLoader = Thread.currentThread().getContextClassLoader(); try { ClassLoader classLoaderToUse = null; ClassDataLoader classDataLoader = null; if (classLoader != null) { classLoaderToUse = classLoader; } else { if (definitionUUID == null) { classDataLoader = EnvTool.getClassDataLoader(); // no need to set the classloader here (using the global // classloader) } else { classLoaderToUse = EnvTool.getClassDataLoader().getProcessClassLoader(definitionUUID); } } if (classLoaderToUse != null) { Thread.currentThread().setContextClassLoader(classLoaderToUse); } return executeInClassLoader(classLoaderToUse, classDataLoader); } finally { Thread.currentThread().setContextClassLoader(baseClassLoader); } }
private void processExecuteMethod(final Object[] args, ClassLoader localClassLoader) throws IOException, ClassNotFoundException { // commomClassLoader if (args.length == 1) { localClassLoader = EnvTool.getClassDataLoader().getCommonClassLoader(); } else if (args.length == 2 && args[1] instanceof ProcessDefinitionUUID) { // processClassLoader localClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader((ProcessDefinitionUUID) args[1]); } Thread.currentThread().setContextClassLoader(localClassLoader); args[0] = ((RESTCommand<?>) args[0]).getCommand(); }
@Override public Map<String, Object> evaluateGroovyExpressions(final Map<String, String> expressions, final ProcessDefinitionUUID processDefinitionUUID, final Map<String, Object> context) throws ProcessNotFoundException, GroovyException { Misc.checkArgsNotNull(processDefinitionUUID); if (expressions == null || expressions.isEmpty()) { return Collections.emptyMap(); } final ClassLoader ori = Thread.currentThread().getContextClassLoader(); try { final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(processDefinitionUUID); Thread.currentThread().setContextClassLoader(processClassLoader); final Binding simpleBinding = GroovyBindingBuilder.getSimpleBinding(processDefinitionUUID, null, null, context, true, true); return evaluateGroovyExpressions(expressions, simpleBinding); } catch (final Exception e) { throw new GroovyException("Exception while getting binding. ProcessDefinitionUUID: " + processDefinitionUUID, e); } finally { if (ori != null && ori != Thread.currentThread().getContextClassLoader()) { Thread.currentThread().setContextClassLoader(ori); } } }
classLoader = EnvTool.getClassDataLoader().getProcessClassLoader(processUUID); if (LOG.isLoggable(Level.FINE)) { LOG.fine("Executing a command. processUUID is not null, processClassLoader found: " + classLoader);
private Object getObjectFromRESTObject(final RESTObject restObject, final ProcessDefinitionUUID processUUID) throws IOException, ClassNotFoundException { Object result = null; ClassLoader localClassLoader = null; try { result = restObject.getObject(); } catch (final ClassNotFoundException e) { // try with ProcessClassLoader localClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(processUUID); Thread.currentThread().setContextClassLoader(localClassLoader); try { result = restObject.getObject(); } catch (final ClassNotFoundException ex) { // try with CommonClassLoader localClassLoader = EnvTool.getClassDataLoader().getCommonClassLoader(); Thread.currentThread().setContextClassLoader(localClassLoader); result = restObject.getObject(); } } return result; }
@Override public Map<String, Object> evaluateGroovyExpressions(final Map<String, String> expressions, final ProcessInstanceUUID processInstanceUUID, final Map<String, Object> context, final boolean useInitialVariableValues, final boolean propagate) throws InstanceNotFoundException, GroovyException { Misc.checkArgsNotNull(processInstanceUUID); if (expressions == null || expressions.isEmpty()) { return Collections.emptyMap(); } final ClassLoader ori = Thread.currentThread().getContextClassLoader(); try { final InternalProcessInstance instance = EnvTool.getAllQueriers().getProcessInstance(processInstanceUUID); final ProcessDefinitionUUID definitionUUID = instance.getProcessDefinitionUUID(); final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(definitionUUID); Thread.currentThread().setContextClassLoader(processClassLoader); final Binding binding = getBinding(definitionUUID, processInstanceUUID, null, context, false, useInitialVariableValues, propagate); final Map<String, Object> results = evaluateGroovyExpressions(expressions, binding); propagateVariablesIfNecessary(null, processInstanceUUID, propagate, binding); return results; } catch (final Exception e) { throw new GroovyException("Exception while evaluating expression. ProcessInstanceUUID: " + processInstanceUUID, e); } finally { if (ori != null && ori != Thread.currentThread().getContextClassLoader()) { Thread.currentThread().setContextClassLoader(ori); } } }
@Override public Map<String, Object> evaluateGroovyExpressions(final Map<String, String> expressions, final ActivityInstanceUUID activityUUID, final Map<String, Object> context, final boolean useActivityScope, final boolean propagate) throws InstanceNotFoundException, ActivityNotFoundException, GroovyException { Misc.checkArgsNotNull(activityUUID); if (expressions == null || expressions.isEmpty()) { return Collections.emptyMap(); } final ClassLoader ori = Thread.currentThread().getContextClassLoader(); try { final InternalActivityInstance activityInstance = EnvTool.getAllQueriers().getActivityInstance(activityUUID); final ProcessDefinitionUUID definitionUUID = activityInstance.getProcessDefinitionUUID(); final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(definitionUUID); Thread.currentThread().setContextClassLoader(processClassLoader); final Binding binding = getBinding(definitionUUID, activityInstance.getProcessInstanceUUID(), activityUUID, context, useActivityScope, false, propagate); final Map<String, Object> results = evaluateGroovyExpressions(expressions, binding); propagateVariablesIfNecessary(activityUUID, null, propagate, binding); return results; } catch (final Exception e) { throw new GroovyException("Exception while evaluating expression. ActivityInstanceUUID: " + activityUUID, e); } finally { if (ori != null && ori != Thread.currentThread().getContextClassLoader()) { Thread.currentThread().setContextClassLoader(ori); } } }
Map<String, Object> newVariableValues = new HashMap<String, Object>(); try { final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(processDefinitionUUID); Thread.currentThread().setContextClassLoader(processClassLoader); if (!inputs.isEmpty()) {
private static Set<String> executeRoleMapper(final TaskInstance task, final Performer performer) { final ProcessDefinitionUUID processUUID = task.getProcessDefinitionUUID(); final RoleMapperDefinition rolemapperDef = performer.getRoleMapperDefinition(); final ClassLoader baseClassLoader = Thread.currentThread().getContextClassLoader(); try { final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(processUUID); Thread.currentThread().setContextClassLoader(processClassLoader); if (rolemapperDef != null) { final RoleMapper roleMapper = EnvTool.getClassDataLoader().getInstance(RoleMapper.class, processUUID, rolemapperDef); try { return ConnectorExecutor.executeRoleMapper(roleMapper, task, performer.getName(), rolemapperDef.getParameters()); } catch (final Exception e) { throw new BonitaWrapperException(new RoleMapperInvocationException("be_TRT_2", rolemapperDef.toString(), e)); } } return null; } finally { Thread.currentThread().setContextClassLoader(baseClassLoader); } }
@Override public Object getModifiedJavaObject(final ProcessDefinitionUUID processUUID, final String variableExpression, final Object variableValue, final Object attributeValue) { final String variableName = Misc.getVariableName(variableExpression); final String groovyPlaceholderAccessExpression = Misc.getGroovyPlaceholderAccessExpression(variableExpression); final String setterName = Misc.getSetterName(variableExpression); final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(processUUID); return modifyJavaObject(variableValue, variableName, groovyPlaceholderAccessExpression, setterName, attributeValue, processClassLoader); }
private static Set<String> executeFilter(final TaskInstance task, final Set<String> candidates, final Performer performer) { final ProcessDefinitionUUID processUUID = task.getProcessDefinitionUUID(); final ClassLoader baseClassLoader = Thread.currentThread().getContextClassLoader(); try { final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(processUUID); Thread.currentThread().setContextClassLoader(processClassLoader); final FilterDefinition filterDefinition = performer.getFilterDefinition(); if (filterDefinition != null) { final PerformerAssign performerAssign = getPerformerAssign(processUUID, filterDefinition); Filter filter = null; if (performerAssign == null) { filter = EnvTool.getClassDataLoader().getInstance(Filter.class, processUUID, filterDefinition); } else { filter = new PerformerAssignFilter(); } try { return ConnectorExecutor.executeFilter(filter, performerAssign, task, candidates, filterDefinition.getParameters()); } catch (final Exception e) { throw new BonitaWrapperException(e); } } return candidates; } finally { Thread.currentThread().setContextClassLoader(baseClassLoader); } }
final ClassLoader baseClassLoader = Thread.currentThread().getContextClassLoader(); try { final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader( activityInstance.getProcessDefinitionUUID()); Thread.currentThread().setContextClassLoader(processClassLoader);
final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(processUUID); Thread.currentThread().setContextClassLoader(processClassLoader);
final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(definitionUUID); Thread.currentThread().setContextClassLoader(processClassLoader); final MultipleInstancesInstantiator activityinstantiator = EnvTool.getClassDataLoader().getInstance(