@Test
  public void testDeploymentOfProcessesKieConteinerInjection() {

    assertNotNull(deploymentService);

    KModuleDeploymentUnit deploymentUnit =
        new KModuleDeploymentUnit(GROUP_ID, ARTIFACT_ID, VERSION, "KBase-test", "ksession-test-2");

    deploymentService.deploy(deploymentUnit);
    units.add(deploymentUnit);

    assertNotNull(deploymentUnit.getDeploymentDescriptor());

    DeployedUnit deployed = deploymentService.getDeployedUnit(deploymentUnit.getIdentifier());
    assertNotNull(deployed);
    assertNotNull(deployed.getDeploymentUnit());
    assertNotNull(deployed.getRuntimeManager());
    assertNull(deployed.getDeployedAssetLocation("customtask"));
    assertEquals(
        GROUP_ID + ":" + ARTIFACT_ID + ":" + VERSION + ":" + "KBase-test" + ":" + "ksession-test-2",
        deployed.getDeploymentUnit().getIdentifier());

    RuntimeManager manager = deploymentService.getRuntimeManager(deploymentUnit.getIdentifier());
    assertNotNull(manager);

    RuntimeEngine engine = manager.getRuntimeEngine(EmptyContext.get());
    assertNotNull(engine);

    Map<String, Object> params = new HashMap<String, Object>();
    params.put("id", "test");
    ProcessInstance processInstance = engine.getKieSession().startProcess("customtask", params);

    assertEquals(ProcessInstance.STATE_COMPLETED, processInstance.getState());
    manager.disposeRuntimeEngine(engine);
  }
  @Test
  public void testStartProcess() throws InterruptedException {
    assertNotNull(deploymentService);

    KModuleDeploymentUnit deploymentUnit =
        new KModuleDeploymentUnit(GROUP_ID, ARTIFACT_ID, VERSION);

    deploymentService.deploy(deploymentUnit);
    units.add(deploymentUnit);
    assertNotNull(processService);

    Map<String, Object> params = new HashMap<String, Object>();
    params.put("expiresAt", "2s");

    long processInstanceId =
        processService.startProcess(
            deploymentUnit.getIdentifier(), "timer-test.timer-process", params);
    assertNotNull(processInstanceId);

    ProcessInstance pi = processService.getProcessInstance(processInstanceId);
    assertNotNull(pi);

    Thread.sleep(3000);

    pi = processService.getProcessInstance(processInstanceId);
    assertNull(pi);
  }
  @Test
  public void testDeploymentOfProcesses() {

    assertNotNull(deploymentService);

    KModuleDeploymentUnit deploymentUnit =
        new KModuleDeploymentUnit(GROUP_ID, ARTIFACT_ID, VERSION, "KBase-test", "ksession-test");

    deploymentService.deploy(deploymentUnit);
    units.add(deploymentUnit);

    assertNotNull(deploymentUnit.getDeploymentDescriptor());

    DeployedUnit deployed = deploymentService.getDeployedUnit(deploymentUnit.getIdentifier());
    assertNotNull(deployed);
    assertNotNull(deployed.getDeploymentUnit());
    assertNotNull(deployed.getRuntimeManager());
    assertNull(deployed.getDeployedAssetLocation("customtask"));
    assertEquals(
        GROUP_ID + ":" + ARTIFACT_ID + ":" + VERSION + ":" + "KBase-test" + ":" + "ksession-test",
        deployed.getDeploymentUnit().getIdentifier());

    assertNotNull(runtimeDataService);
    Collection<ProcessDefinition> processes = runtimeDataService.getProcesses(new QueryContext());
    assertNotNull(processes);
    assertEquals(3, processes.size());

    processes = runtimeDataService.getProcessesByFilter("custom", new QueryContext());
    assertNotNull(processes);
    assertEquals(1, processes.size());

    processes =
        runtimeDataService.getProcessesByDeploymentId(
            deploymentUnit.getIdentifier(), new QueryContext());
    assertNotNull(processes);
    assertEquals(3, processes.size());

    ProcessDefinition process = runtimeDataService.getProcessById("customtask");
    assertNotNull(process);

    RuntimeManager manager = deploymentService.getRuntimeManager(deploymentUnit.getIdentifier());
    assertNotNull(manager);

    RuntimeEngine engine = manager.getRuntimeEngine(EmptyContext.get());
    assertNotNull(engine);

    Map<String, Object> params = new HashMap<String, Object>();
    params.put("id", "test");
    ProcessInstance processInstance = engine.getKieSession().startProcess("customtask", params);

    assertEquals(ProcessInstance.STATE_COMPLETED, processInstance.getState());
  }
 protected RegisterableItemsFactory getRegisterableItemsFactory(
     AuditEventBuilder auditLoggerBuilder, KieContainer kieContainer, KModuleDeploymentUnit unit) {
   KModuleRegisterableItemsFactory factory =
       new KModuleRegisterableItemsFactory(kieContainer, unit.getKsessionName());
   factory.setAuditBuilder(auditLoggerBuilder);
   return factory;
 }
  @Override
  protected RegisterableItemsFactory getRegisterableItemsFactory(
      AuditEventBuilder auditLoggerBuilder, KieContainer kieContainer, KModuleDeploymentUnit unit) {

    return InjectableRegisterableItemsFactory.getFactory(
        beanManager, auditLoggerBuilder, kieContainer, unit.getKsessionName());
  }
  @Test
  public void deploymentObjectsTest() throws Exception {
    Assume.assumeFalse(getType().equals(TestType.YAML));

    // for test at end, fill during test
    JaxbDeploymentUnitList depUnitList = new JaxbDeploymentUnitList();

    // dep jobs
    JaxbDeploymentJobResult jaxbJob = new JaxbDeploymentJobResult();
    testRoundTrip(jaxbJob);

    // complex dep jobs
    KModuleDeploymentUnit kDepUnit =
        new KModuleDeploymentUnit("org", "jar", "1.0", "kbase", "ksession");
    kDepUnit.setStrategy(RuntimeStrategy.PER_PROCESS_INSTANCE);

    JaxbDeploymentUnit depUnit =
        new JaxbDeploymentUnit(
            kDepUnit.getGroupId(), kDepUnit.getArtifactId(), kDepUnit.getArtifactId());
    depUnit.setKbaseName(kDepUnit.getKbaseName());
    depUnit.setKsessionName(kDepUnit.getKsessionName());
    depUnit.setStrategy(kDepUnit.getStrategy());
    depUnit.setStatus(JaxbDeploymentStatus.NONEXISTENT);
    depUnitList.getDeploymentUnitList().add(depUnit);

    jaxbJob = new JaxbDeploymentJobResult(null, "test", depUnit, "deploy");
    jaxbJob.setIdentifier(23L);
    jaxbJob.setSuccess(false);
    JaxbDeploymentJobResult copyJaxbJob = testRoundTrip(jaxbJob);
    ComparePair.compareObjectsViaFields(jaxbJob, copyJaxbJob, "jobId", "identifier");

    depUnit = new JaxbDeploymentUnit("g", "a", "v");
    depUnit.setKbaseName("kbase");
    depUnit.setKsessionName("ksession");
    depUnit.setStatus(JaxbDeploymentStatus.DEPLOY_FAILED);
    depUnit.setStrategy(RuntimeStrategy.PER_PROCESS_INSTANCE);
    depUnitList.getDeploymentUnitList().add(depUnit);

    JaxbDeploymentUnit copyDepUnit = testRoundTrip(depUnit);

    ComparePair.compareObjectsViaFields(depUnit, copyDepUnit, "identifier");

    JaxbDeploymentJobResult depJob =
        new JaxbDeploymentJobResult(null, "testing stuff", copyDepUnit, "test");
    depJob.setSuccess(true);
    JaxbDeploymentJobResult copyDepJob = testRoundTrip(depJob);

    ComparePair.compareObjectsViaFields(copyDepJob, depJob, "jobId", "identifier");

    JaxbDeploymentUnitList roundTripUnitList = testRoundTrip(depUnitList);
    ComparePair.compareObjectsViaFields(
        depUnitList.getDeploymentUnitList().get(0),
        roundTripUnitList.getDeploymentUnitList().get(0),
        "jobId",
        "identifier");
  }
  @Override
  public void undeploy(DeploymentUnit unit) {
    if (!(unit instanceof KModuleDeploymentUnit)) {
      throw new IllegalArgumentException(
          "Invalid deployment unit provided - " + unit.getClass().getName());
    }
    KModuleDeploymentUnit kmoduleUnit = (KModuleDeploymentUnit) unit;
    super.undeploy(unit);

    formManagerService.unRegisterForms(unit.getIdentifier());

    KieServices ks = KieServices.Factory.get();
    ReleaseId releaseId =
        ks.newReleaseId(
            kmoduleUnit.getGroupId(), kmoduleUnit.getArtifactId(), kmoduleUnit.getVersion());
    ks.getRepository().removeKieModule(releaseId);
  }
Beispiel #8
0
  /**
   * Returns a RuntimeManager from the ProcessEngineService for the given KModuleDeploymentUnit.
   * Creates a RuntimeManager if it didn't already exist.
   *
   * @param processEngineService
   * @param unit
   * @return RuntimeManager
   */
  public RuntimeManager getRuntimeManager(
      ProcessEngineService processEngineService, KModuleDeploymentUnit unit) {

    // First see if we have one
    RuntimeManager runtimeManager = processEngineService.getRuntimeManager(unit.getIdentifier());
    if (runtimeManager == null) {
      if (isSRAMPPackageDeployed(unit.getGroupId(), unit.getArtifactId(), unit.getVersion())) {
        unit.setStrategy(RuntimeStrategy.PER_PROCESS_INSTANCE);
        processEngineService.deployUnit(unit);
        runtimeManager = processEngineService.getRuntimeManager(unit.getIdentifier());
        logger.info(
            Messages.i18n.format(
                "KieSrampUtil.FoundAndDeployed", unit.getIdentifier())); // $NON-NLS-1$
      } else {
        logger.error(
            Messages.i18n.format("KieSrampUtil.NotFound", unit.getIdentifier())); // $NON-NLS-1$
        throw new IllegalStateException(
            Messages.i18n.format("KieSrampUtil.NotFound", unit.getIdentifier())); // $NON-NLS-1$
      }
    }
    return runtimeManager;
  }
  @Test
  public void testStartProcessWithHTDeadline() throws InterruptedException {
    assertNotNull(deploymentService);

    KModuleDeploymentUnit deploymentUnit =
        new KModuleDeploymentUnit(GROUP_ID, ARTIFACT_ID, VERSION);

    deploymentService.deploy(deploymentUnit);
    units.add(deploymentUnit);
    assertNotNull(processService);

    processInstanceId =
        processService.startProcess(deploymentUnit.getIdentifier(), "htdeadlinetest");

    List<TaskSummary> krisTasks =
        runtimeDataService.getTasksAssignedAsPotentialOwner("krisv", new QueryFilter());
    assertEquals(1, krisTasks.size());
    List<TaskSummary> johnTasks =
        runtimeDataService.getTasksAssignedAsPotentialOwner("john", new QueryFilter());
    assertEquals(0, johnTasks.size());
    List<TaskSummary> maryTasks =
        runtimeDataService.getTasksAssignedAsPotentialOwner("mary", new QueryFilter());
    assertEquals(0, maryTasks.size());

    // now wait for 2 seconds for first reassignment
    Thread.sleep(3000);

    krisTasks = runtimeDataService.getTasksAssignedAsPotentialOwner("krisv", new QueryFilter());
    assertEquals(0, krisTasks.size());
    johnTasks = runtimeDataService.getTasksAssignedAsPotentialOwner("john", new QueryFilter());
    assertEquals(1, johnTasks.size());
    maryTasks = runtimeDataService.getTasksAssignedAsPotentialOwner("mary", new QueryFilter());
    assertEquals(0, maryTasks.size());

    userTaskService.start(johnTasks.get(0).getId(), "john");

    // now wait for 2 more seconds for second reassignment
    Thread.sleep(2000);
    krisTasks = runtimeDataService.getTasksAssignedAsPotentialOwner("krisv", new QueryFilter());
    assertEquals(0, krisTasks.size());
    johnTasks = runtimeDataService.getTasksAssignedAsPotentialOwner("john", new QueryFilter());
    assertEquals(1, johnTasks.size());
    maryTasks = runtimeDataService.getTasksAssignedAsPotentialOwner("mary", new QueryFilter());
    assertEquals(0, maryTasks.size());

    // now wait for 1 seconds to make sure that reassignment did not happen any more since task was
    // already started
    Thread.sleep(3000);

    krisTasks = runtimeDataService.getTasksAssignedAsPotentialOwner("krisv", new QueryFilter());
    assertEquals(0, krisTasks.size());
    johnTasks = runtimeDataService.getTasksAssignedAsPotentialOwner("john", new QueryFilter());
    assertEquals(0, johnTasks.size());
    maryTasks = runtimeDataService.getTasksAssignedAsPotentialOwner("mary", new QueryFilter());
    assertEquals(1, maryTasks.size());
    userTaskService.start(maryTasks.get(0).getId(), "mary");
    userTaskService.complete(maryTasks.get(0).getId(), "mary", null);

    // now wait for 2 seconds to make sure that reassignment did not happen any more since task was
    // completed
    Thread.sleep(2000);

    ProcessInstance processInstance = processService.getProcessInstance(processInstanceId);
    assertNull(processInstance);
    processInstanceId = null;
  }
  /**
   * 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());
  }