/** * This processes the deployment dependencies, which are made available by the {@link * KieContainer} {@link ClassLoader}. * * @param kieContainer The {@link KieContainer}, used to get the {@link ClassLoader} * @param deployedUnit The {@link DeployedUnitImpl}, used to store the classes loaded */ protected void processClassloader(KieContainer kieContainer, DeployedUnitImpl deployedUnit) { if (kieContainer.getClassLoader() instanceof ProjectClassLoader) { ClassLoader parentCl = kieContainer.getClassLoader().getParent(); if (parentCl instanceof URLClassLoader) { URL[] urls = ((URLClassLoader) parentCl).getURLs(); if (urls == null || urls.length == 0) { return; } ConfigurationBuilder builder = new ConfigurationBuilder(); builder.addUrls(urls); builder.addClassLoader(kieContainer.getClassLoader()); Reflections reflections = new Reflections(builder); Set<Class<?>> xmlRootElemClasses = reflections.getTypesAnnotatedWith(XmlRootElement.class); Set<Class<?>> xmlTypeClasses = reflections.getTypesAnnotatedWith(XmlType.class); Set<Class<?>> remoteableClasses = reflections.getTypesAnnotatedWith(Remotable.class); Set<Class<?>> allClasses = new HashSet<Class<?>>(); for (Set<Class<?>> classesToAdd : new Set[] {xmlRootElemClasses, xmlTypeClasses, remoteableClasses}) { if (classesToAdd != null) { allClasses.addAll(classesToAdd); } } for (Class<?> clazz : allClasses) { filterClassesAddedToDeployedUnit(deployedUnit, clazz); } } } }
/** * Goes through all files in a deployment, and processes them so that they are then ready for use * after deployment. * * @param module The {@link InternalKieModule}, necessary to get form content * @param files The {@link List} of file (names) to process. * @param kieContainer The {@link KieContainer}, necesary in order to load classes * @param deploymentUnit The {@link DeploymentUnit}, necessary to get the deployment id * @param deployedUnit The {@link DeployedUnit}, which contains the results of actions here */ protected void processResources( InternalKieModule module, Collection<String> files, KieContainer kieContainer, DeploymentUnit unit, DeployedUnitImpl deployedUnit, ReleaseId releaseId, Map<String, ProcessDescriptor> processes) { for (String fileName : files) { if (fileName.matches(".+bpmn[2]?$")) { ProcessAssetDesc process; try { String processString = new String(module.getBytes(fileName), "UTF-8"); String processId = getProcessId(processString); ProcessDescriptor processDesriptor = processes.get(processId); if (processDesriptor != null) { process = processDesriptor.getProcess(); if (process == null) { throw new IllegalArgumentException("Unable to read process " + fileName); } process.setEncodedProcessSource(Base64.encodeBase64String(processString.getBytes())); process.setDeploymentId(unit.getIdentifier()); deployedUnit.addAssetLocation(process.getId(), process); bpmn2Service.addProcessDefinition( unit.getIdentifier(), processId, processDesriptor, kieContainer); } } catch (UnsupportedEncodingException e) { throw new IllegalArgumentException( "Unsupported encoding while processing process " + fileName); } } else if (fileName.matches(".+ftl$") || fileName.matches(".+form$") || fileName.matches(".+frm$")) { try { String formContent = new String(module.getBytes(fileName), "UTF-8"); if (fileName.indexOf("/") != -1) fileName = fileName.substring(fileName.lastIndexOf("/") + 1); formManagerService.registerForm(unit.getIdentifier(), fileName, formContent); } catch (UnsupportedEncodingException e) { throw new IllegalArgumentException( "Unsupported encoding while processing form " + fileName); } } else if (fileName.matches(".+class$")) { // Classes 1: classes from deployment added String className = fileName.replaceAll("/", "."); className = className.substring(0, fileName.length() - ".class".length()); Class deploymentClass = null; try { deploymentClass = kieContainer.getClassLoader().loadClass(className); } catch (ClassNotFoundException cnfe) { throw new IllegalArgumentException("Class " + className + " not found in the project"); } catch (NoClassDefFoundError e) { throw new IllegalArgumentException("Class " + className + " not found in the project"); } addClassToDeployedUnit(deploymentClass, deployedUnit); } } }
private static Object createMessage(KieContainer kContainer, String name, String text) { Object o = null; try { Class cl = kContainer.getClassLoader().loadClass("org.drools.example.api.namedkiesession.Message"); o = cl.getConstructor(new Class[] {String.class, String.class}).newInstance(name, text); } catch (Exception e) { e.printStackTrace(); } return o; }
protected Object getInstanceFromModel( ObjectModel model, KieContainer kieContainer, Map<String, Object> contaxtParams) { ObjectModelResolver resolver = ObjectModelResolverProvider.get(model.getResolver()); if (resolver == null) { // if we don't throw an exception here, we have an NPE below.. throw new IllegalStateException( "Unable to find ObjectModelResolver for " + model.getResolver()); } return resolver.getInstance(model, kieContainer.getClassLoader(), contaxtParams); }
@Override protected void addExtraCustomClasses(Map<String, Class<?>> extraClasses) throws Exception { KieContainer kieContainer = KieServices.Factory.get().newKieContainer(kjar1); extraClasses.put( PERSON_CLASS_NAME, Class.forName(PERSON_CLASS_NAME, true, kieContainer.getClassLoader())); }
/** * This creates and fills a {@link RuntimeEnvironmentBuilder} instance, which is later used when * creating services. A lot of the logic here is used to process the information in the {@link * DeploymentDescriptor} instance, which is part of the {@link DeploymentUnit}. * * @param deploymentUnit The {@link KModuleDeploymentUnit}, which is filled by the method * @param deployedUnit The {@link DeployedUnit}, which is also filled by the method * @param kieContainer The {@link KieContainer}, which contains information needed to fill the * above two arguments * @param mode The {@link MergeMode} used to resolve conflicts in the {@link * DeploymentDescriptor}. * @return A {@link RuntimeEnvironmentBuilder} instance ready for use */ protected RuntimeEnvironmentBuilder boostrapRuntimeEnvironmentBuilder( KModuleDeploymentUnit deploymentUnit, DeployedUnit deployedUnit, KieContainer kieContainer, MergeMode mode) { DeploymentDescriptor descriptor = deploymentUnit.getDeploymentDescriptor(); if (descriptor == null || ((DeploymentDescriptorImpl) descriptor) .isEmpty()) { // skip empty descriptors as its default can override settings DeploymentDescriptorManager descriptorManager = new DeploymentDescriptorManager("org.jbpm.domain"); List<DeploymentDescriptor> descriptorHierarchy = descriptorManager.getDeploymentDescriptorHierarchy(kieContainer); descriptor = merger.merge(descriptorHierarchy, mode); deploymentUnit.setDeploymentDescriptor(descriptor); } else if (descriptor != null && !deploymentUnit.isDeployed()) { DeploymentDescriptorManager descriptorManager = new DeploymentDescriptorManager("org.jbpm.domain"); List<DeploymentDescriptor> descriptorHierarchy = descriptorManager.getDeploymentDescriptorHierarchy(kieContainer); descriptorHierarchy.add(0, descriptor); descriptor = merger.merge(descriptorHierarchy, mode); deploymentUnit.setDeploymentDescriptor(descriptor); } // first set on unit the strategy deploymentUnit.setStrategy(descriptor.getRuntimeStrategy()); // setting up runtime environment via builder RuntimeEnvironmentBuilder builder = null; if (descriptor.getPersistenceMode() == PersistenceMode.NONE) { builder = RuntimeEnvironmentBuilder.Factory.get().newDefaultInMemoryBuilder(); } else { builder = RuntimeEnvironmentBuilder.Factory.get().newDefaultBuilder(); } // populate various properties of the builder EntityManagerFactory emf = EntityManagerFactoryManager.get().getOrCreate(descriptor.getPersistenceUnit()); builder.entityManagerFactory(emf); Map<String, Object> contaxtParams = new HashMap<String, Object>(); contaxtParams.put("entityManagerFactory", emf); contaxtParams.put("classLoader", kieContainer.getClassLoader()); // process object models that are globally configured (environment entries, session // configuration) for (NamedObjectModel model : descriptor.getEnvironmentEntries()) { Object entry = getInstanceFromModel(model, kieContainer, contaxtParams); builder.addEnvironmentEntry(model.getName(), entry); } for (NamedObjectModel model : descriptor.getConfiguration()) { Object entry = getInstanceFromModel(model, kieContainer, contaxtParams); builder.addConfiguration(model.getName(), (String) entry); } ObjectMarshallingStrategy[] mStrategies = new ObjectMarshallingStrategy[descriptor.getMarshallingStrategies().size() + 1]; int index = 0; for (ObjectModel model : descriptor.getMarshallingStrategies()) { Object strategy = getInstanceFromModel(model, kieContainer, contaxtParams); mStrategies[index] = (ObjectMarshallingStrategy) strategy; index++; } // lastly add the main default strategy mStrategies[index] = new SerializablePlaceholderResolverStrategy(ClassObjectMarshallingStrategyAcceptor.DEFAULT); builder.addEnvironmentEntry(EnvironmentName.OBJECT_MARSHALLING_STRATEGIES, mStrategies); builder.addEnvironmentEntry("KieDeploymentDescriptor", descriptor); builder.addEnvironmentEntry("KieContainer", kieContainer); if (executorService != null) { builder.addEnvironmentEntry("ExecutorService", executorService); } // populate all assets with roles for this deployment unit List<String> requiredRoles = descriptor.getRequiredRoles(DeploymentDescriptor.TYPE_VIEW); if (requiredRoles != null && !requiredRoles.isEmpty()) { for (DeployedAsset desc : deployedUnit.getDeployedAssets()) { if (desc instanceof ProcessAssetDesc) { ((ProcessAssetDesc) desc).setRoles(requiredRoles); } } } // Classes 3: classes added from descriptor List<String> remoteableClasses = descriptor.getClasses(); if (remoteableClasses != null && !remoteableClasses.isEmpty()) { for (String className : remoteableClasses) { Class descriptorClass = null; try { descriptorClass = kieContainer.getClassLoader().loadClass(className); logger.debug( "Loaded {} into the classpath from deployment descriptor {}", className, kieContainer.getReleaseId().toExternalForm()); } catch (ClassNotFoundException cnfe) { throw new IllegalArgumentException("Class " + className + " not found in the project"); } catch (NoClassDefFoundError e) { throw new IllegalArgumentException("Class " + className + " not found in the project"); } addClassToDeployedUnit(descriptorClass, (DeployedUnitImpl) deployedUnit); } } return builder; }
@Override public void deploy(DeploymentUnit unit) { try { super.deploy(unit); if (!(unit instanceof KModuleDeploymentUnit)) { throw new IllegalArgumentException( "Invalid deployment unit provided - " + unit.getClass().getName()); } KModuleDeploymentUnit kmoduleUnit = (KModuleDeploymentUnit) unit; DeployedUnitImpl deployedUnit = new DeployedUnitImpl(unit); // Create the release id KieContainer kieContainer = kmoduleUnit.getKieContainer(); ReleaseId releaseId = null; if (kieContainer == null) { KieServices ks = KieServices.Factory.get(); releaseId = ks.newReleaseId( kmoduleUnit.getGroupId(), kmoduleUnit.getArtifactId(), kmoduleUnit.getVersion()); MavenRepository repository = getMavenRepository(); repository.resolveArtifact(releaseId.toExternalForm()); kieContainer = ks.newKieContainer(releaseId); kmoduleUnit.setKieContainer(kieContainer); } releaseId = kieContainer.getReleaseId(); // retrieve the kbase name String kbaseName = kmoduleUnit.getKbaseName(); if (StringUtils.isEmpty(kbaseName)) { KieBaseModel defaultKBaseModel = ((KieContainerImpl) kieContainer).getKieProject().getDefaultKieBaseModel(); if (defaultKBaseModel != null) { kbaseName = defaultKBaseModel.getName(); } else { kbaseName = DEFAULT_KBASE_NAME; } } InternalKieModule module = (InternalKieModule) ((KieContainerImpl) kieContainer).getKieModuleForKBase(kbaseName); if (module == null) { throw new IllegalStateException( "Cannot find kbase, either it does not exist or there are multiple default kbases in kmodule.xml"); } KieBase kbase = kieContainer.getKieBase(kbaseName); Map<String, ProcessDescriptor> processDescriptors = new HashMap<String, ProcessDescriptor>(); for (org.kie.api.definition.process.Process process : kbase.getProcesses()) { processDescriptors.put( process.getId(), (ProcessDescriptor) process.getMetaData().get("ProcessDescriptor")); } // TODO: add forms data? Collection<String> files = module.getFileNames(); processResources( module, files, kieContainer, kmoduleUnit, deployedUnit, releaseId, processDescriptors); // process the files in the deployment if (module.getKieDependencies() != null) { Collection<InternalKieModule> dependencies = module.getKieDependencies().values(); for (InternalKieModule depModule : dependencies) { logger.debug("Processing dependency module " + depModule.getReleaseId()); files = depModule.getFileNames(); processResources( depModule, files, kieContainer, kmoduleUnit, deployedUnit, depModule.getReleaseId(), processDescriptors); } } Collection<ReleaseId> dependencies = module.getJarDependencies(new DependencyFilter.ExcludeScopeFilter("test", "provided")); // process deployment dependencies if (dependencies != null && !dependencies.isEmpty()) { // Classes 2: classes added from project and dependencies added processClassloader(kieContainer, deployedUnit); } AuditEventBuilder auditLoggerBuilder = setupAuditLogger(identityProvider, unit.getIdentifier()); RuntimeEnvironmentBuilder builder = boostrapRuntimeEnvironmentBuilder( kmoduleUnit, deployedUnit, kieContainer, kmoduleUnit.getMergeMode()) .knowledgeBase(kbase) .classLoader(kieContainer.getClassLoader()); builder.registerableItemsFactory( getRegisterableItemsFactory(auditLoggerBuilder, kieContainer, kmoduleUnit)); commonDeploy(unit, deployedUnit, builder.get(), kieContainer); kmoduleUnit.setDeployed(true); } catch (Throwable e) { logger.warn("Unexpected error while deploying unit {}", unit.getIdentifier(), e); // catch all possible errors to be able to report them to caller as RuntimeException throw new RuntimeException(e); } }
@Override public void deploy(DeploymentUnit unit) { super.deploy(unit); if (!(unit instanceof KModuleDeploymentUnit)) { throw new IllegalArgumentException( "Invalid deployment unit provided - " + unit.getClass().getName()); } KModuleDeploymentUnit kmoduleUnit = (KModuleDeploymentUnit) unit; DeployedUnitImpl deployedUnit = new DeployedUnitImpl(unit); KieServices ks = KieServices.Factory.get(); MavenRepository repository = getMavenRepository(); repository.resolveArtifact(kmoduleUnit.getIdentifier()); ReleaseId releaseId = ks.newReleaseId( kmoduleUnit.getGroupId(), kmoduleUnit.getArtifactId(), kmoduleUnit.getVersion()); KieContainer kieContainer = ks.newKieContainer(releaseId); String kbaseName = kmoduleUnit.getKbaseName(); if (StringUtils.isEmpty(kbaseName)) { KieBaseModel defaultKBaseModel = ((KieContainerImpl) kieContainer).getKieProject().getDefaultKieBaseModel(); if (defaultKBaseModel != null) { kbaseName = defaultKBaseModel.getName(); } else { kbaseName = DEFAULT_KBASE_NAME; } } InternalKieModule module = (InternalKieModule) ((KieContainerImpl) kieContainer).getKieModuleForKBase(kbaseName); if (module == null) { throw new IllegalStateException("Cannot find kbase with name " + kbaseName); } Map<String, String> formsData = new HashMap<String, String>(); Collection<String> files = module.getFileNames(); for (String fileName : files) { if (fileName.matches(".+bpmn[2]?$")) { ProcessDesc process; try { String processString = new String(module.getBytes(fileName), "UTF-8"); process = bpmn2Service.findProcessId(processString, kieContainer.getClassLoader()); process.setEncodedProcessSource(Base64.encodeBase64String(processString.getBytes())); process.setDeploymentId(unit.getIdentifier()); process.setForms(formsData); deployedUnit.addAssetLocation(process.getId(), process); } catch (UnsupportedEncodingException e) { logger.warn("Unable to load content for file '{}' : {}", fileName, e); } } else if (fileName.matches(".+ftl$")) { try { String formContent = new String(module.getBytes(fileName), "UTF-8"); Pattern regex = Pattern.compile("(.{0}|.*/)([^/]*?)\\.ftl"); Matcher m = regex.matcher(fileName); String key = fileName; while (m.find()) { key = m.group(2); } formsData.put(key, formContent); } catch (UnsupportedEncodingException e) { logger.warn("Unable to load content for form '{}' : {}", fileName, e); } } else if (fileName.matches(".+form$")) { try { String formContent = new String(module.getBytes(fileName), "UTF-8"); Pattern regex = Pattern.compile("(.{0}|.*/)([^/]*?)\\.form"); Matcher m = regex.matcher(fileName); String key = fileName; while (m.find()) { key = m.group(2); } formsData.put(key + ".form", formContent); } catch (UnsupportedEncodingException e) { logger.warn("Unable to load content for form '{}' : {}", fileName, e); } } } KieBase kbase = kieContainer.getKieBase(kbaseName); AbstractAuditLogger auditLogger = getAuditLogger(); ServicesAwareAuditEventBuilder auditEventBuilder = new ServicesAwareAuditEventBuilder(); auditEventBuilder.setIdentityProvider(identityProvider); auditEventBuilder.setDeploymentUnitId(unit.getIdentifier()); auditLogger.setBuilder(auditEventBuilder); RuntimeEnvironmentBuilder builder = RuntimeEnvironmentBuilder.getDefault() .entityManagerFactory(getEmf()) .knowledgeBase(kbase) .classLoader(kieContainer.getClassLoader()); if (beanManager != null) { builder.registerableItemsFactory( InjectableRegisterableItemsFactory.getFactory( beanManager, auditLogger, kieContainer, kmoduleUnit.getKsessionName())); } commonDeploy(unit, deployedUnit, builder.get()); }