protected static Object getInstance(final PackageDefinitionUUID packageUUID, final ClassInfo classInfo) { final String className = classInfo.getClassName(); try { final Class< ? > clazz = getClass(packageUUID, className); return getClassInstance(clazz, classInfo); } catch (final ClassNotFoundException e) { throw new BonitaRuntimeException("The following class was not found : " + className); } }
public static Object getHookInstance(PackageDefinitionUUID packageUUID, ClassInfo classInfo) { Object obj = getInstance(packageUUID, classInfo); if (!(obj instanceof Hook) && !(obj instanceof TxHook)) { throw new BonitaRuntimeException("The given class : " + classInfo + " is not a Hook instance neither a TxHook instance"); } return obj; }
public static Class< ? > getClass(final PackageDefinitionUUID packageUUID, final String className) throws ClassNotFoundException { if (LOG.isLoggable(Level.FINE)) { LOG.fine("Looking for class " + className + ", in package : " + packageUUID); } Class< ? > result = null; if (packageUUID != null) { result = lookIntoPackageClassLoader(packageUUID, className); } if (result != null) { return result; } if (LOG.isLoggable(Level.FINE)) { LOG.fine("Class " + className + " not found in packageClassLoaders..."); } result = lookIntoCommonClassLoader(className); if (result != null) { return result; } if (LOG.isLoggable(Level.FINE)) { LOG.fine("Class " + className + " not found in globalClassLoaders..."); } //maybe it is present in the current classLoader ? It may be a class delivered in bonita jar ? return load(ClassDataLoader.class.getClassLoader(), className); }
private static Class< ? > lookIntoGlobalClassLoader(Repository repository, String className) { ClassLoader classLoader = getGlobalClassLoader(repository, className); if (classLoader != null) { try { Class< ? > result = load(classLoader, className); if (result != null && result.getClassLoader().equals(classLoader)) { return result; } } catch (ClassNotFoundException e) { return null; } } return null; }
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); } }
if (performerAssignInfo != null) { final PerformerAssign performerAssign = ClassDataLoader.getInstance(PerformerAssign.class, this.packageUUID, performerAssignInfo); Map<String, String> parameters = performerAssignInfo.getParameters(); if (parameters != null) { Class<?> clazz = null; try { clazz = ClassDataLoader.getClass(this.packageUUID, performerAssignInfo.getClassName()); } catch (ClassNotFoundException e) { e.printStackTrace();
public static Class< ? > getClass(PackageDefinitionUUID packageUUID, String className) throws ClassNotFoundException { if (LOG.isLoggable(Level.FINE)) { LOG.fine("Looking for class " + className + ", in package : " + packageUUID); } Repository repository = EnvTool.getRepository(); Class< ? > result = lookIntoPackageClassLoader(packageUUID, repository, className); if (result != null) { return result; } if (LOG.isLoggable(Level.FINE)) { LOG.fine("Class " + className + " not found in packageClassLoaders..."); } result = lookIntoGlobalClassLoader(repository, className); if (result != null) { return result; } if (LOG.isLoggable(Level.FINE)) { LOG.fine("Class " + className + " not found in globalClassLoaders..."); } //maybe it is present in the current classLoader ? It may be a class delivered in bonita jar ? return load(ClassDataLoader.class.getClassLoader(), className); }
Set<IterationDescriptor> iterationDescriptors = null; try { final ClassLoader processClassloader = EnvTool.getClassDataLoader().getProcessClassLoader(processUUID); Thread.currentThread().setContextClassLoader(processClassloader); process = businessArchive.getProcessDefinition(); for (final String className : process.getClassDependencies()) { try { EnvTool.getClassDataLoader().getClass(process.getUUID(), className); } catch (final ClassNotFoundException e) { final String message = ExceptionManager.getInstance() Thread.currentThread().setContextClassLoader(EnvTool.getClassDataLoader().getProcessClassLoader(processUUID)); internalProcess = new InternalProcessDefinition(process); EnvTool.getClassDataLoader().removeProcessClassLoader(processUUID); if (removeDeps) { ldr.deleteData(Misc.getBusinessArchiveCategories(processUUID));
Class< ? > clazz = null; try { clazz = ClassDataLoader.getClass(packageDef.getUUID(), className); } catch (ClassNotFoundException e) { throw new DeploymentRuntimeException("Problem while deploying package: " + packageId for (String className : packageDef.getClassDependencies()) { try { ClassDataLoader.getClass(packageDef.getUUID(), className); } catch (ClassNotFoundException e) { throw new DeploymentRuntimeException("Problem while deploying package: " + packageId ClassDataLoader.removePackageClassLoader(packageDef.getUUID());
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(); }
public Class<?> getClass(final ProcessDefinitionUUID processUUID, final String className) throws ClassNotFoundException { if (LOG.isLoggable(Level.FINE)) { LOG.fine("Looking for class " + className + ", in process : " + processUUID); } Class<?> result = null; if (processUUID != null) { result = lookIntoProcessClassLoader(processUUID, className); } if (result != null) { return result; } if (LOG.isLoggable(Level.FINE)) { LOG.fine("Class " + className + " not found in packageClassLoaders..."); } result = lookIntoCommonClassLoader(className); if (result != null) { return result; } if (LOG.isLoggable(Level.FINE)) { LOG.fine("Class " + className + " not found in globalClassLoaders..."); } // maybe it is present in the current classLoader ? It may be a class delivered in bonita jar ? return ClassDataLoader.class.getClassLoader().loadClass(className); }
private static Class< ? > lookIntoCommonClassLoader(final String className) { try { synchronized (CommonClassLoader.LOCK) { return load(CommonClassLoader.getCurrent(), className); } } catch (final ClassNotFoundException e) { return null; } }
private DocumentContent getDocumentContent(final String documentId) throws DocumentNotFoundException { DocumentContent documentContent = null; final ClassLoader ori = Thread.currentThread().getContextClassLoader(); try { // it's necessary to set the Classloader to avoid exception while using // the Studio // java.lang.IllegalArgumentException: interface // org.hibernate.engine.jdbc.WrappedBlob is not visible from class loader final CommonClassLoader commonClassLoader = EnvTool.getClassDataLoader().getCommonClassLoader(); Thread.currentThread().setContextClassLoader(commonClassLoader); documentContent = getDbSession().getDocumentContent(Long.valueOf(documentId)); } finally { if (ori != null) { Thread.currentThread().setContextClassLoader(ori); } } if (documentContent == null) { throw new DocumentNotFoundException(documentId); } return documentContent; }
classLoader = ClassDataLoader.getGlobalClassLoader(repository, this.className);
ClassDataLoader.getActivityInstantiatorInstance( xpdlExecution.getXpdlInstance().getPackageDefinitionUUID(), multiInstantiationClass); try {
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); } }
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; }
private static Class< ? > lookIntoPackageClassLoader(PackageDefinitionUUID packageUUID, Repository repository, String className) { PackageClassData packageClassData = repository.getPackageClassData(packageUUID); if (packageClassData != null) { if (LOG.isLoggable(Level.FINE)) { LOG.fine("Class " + className + " is defined in package : " + packageUUID); } if (!packageClassLoaders.containsKey(packageUUID)) { BonitaClassLoader bonitaClassLoader = new BonitaClassLoader(packageClassData.getClasses()); packageClassLoaders.put(packageUUID, bonitaClassLoader); } ClassLoader classLoader = packageClassLoaders.get(packageUUID); try { Class< ? > result = load(classLoader, className); if (result != null && result.getClassLoader().equals(classLoader)) { return result; } } catch (ClassNotFoundException e) { return null; } } return null; }
@Override public DocumentVersion storeDocumentContent(final DocumentVersion document, final byte[] documentContent) throws DocumentationCreationException { final ClassLoader ori = Thread.currentThread().getContextClassLoader(); try { // it's necessary to set the class loader to avoid exception while using the Studio // java.lang.IllegalArgumentException: interface org.hibernate.engine.jdbc.BlobImplementer is not visible from class loader final CommonClassLoader commonClassLoader = EnvTool.getClassDataLoader().getCommonClassLoader(); Thread.currentThread().setContextClassLoader(commonClassLoader); final DocumentContentImpl content = new DocumentContentImpl(documentContent); getDbSession().save(content); document.setContentStorageId(content.getId()); return document; } finally { if (ori != null) { Thread.currentThread().setContextClassLoader(ori); } } }
private static PerformerAssign getPerformerAssign(final ProcessDefinitionUUID processUUID, final FilterDefinition filterDefinition) { try { return EnvTool.getClassDataLoader().getInstance(PerformerAssign.class, processUUID, filterDefinition); } catch (final Exception e) { return null; } }