org.camunda.bpm.application.ProcessApplicationInterface Java Examples

protected ProcessApplicationInterface getProcessApplication() {
  ProcessApplicationReference reference = processEngineConfiguration.getCommandExecutorTxRequired().execute(new Command<ProcessApplicationReference>() {
    public ProcessApplicationReference execute(CommandContext commandContext) {
      ProcessDefinitionEntity definition = commandContext
          .getProcessDefinitionManager()
          .findLatestProcessDefinitionByKey(PROCESS_ID);
      String deploymentId = definition.getDeploymentId();
      ProcessApplicationManager processApplicationManager = processEngineConfiguration.getProcessApplicationManager();
      return processApplicationManager.getProcessApplicationForDeployment(deploymentId);
    }
  });

  assertNotNull(reference);

  ProcessApplicationInterface processApplication = null;
  try {
    processApplication = reference.getProcessApplication();
  } catch (ProcessApplicationUnavailableException e) {
    fail("Could not retrieve process application");
  }

  return processApplication.getRawObject();
}
 

protected void invokePreUndeploy(final ProcessApplicationInterface processApplication) throws ClassNotFoundException {
  if(preUndeployDescription != null) {
    Class<?> paClass = getPaClass(preUndeployDescription);
    final Method preUndeployMethod = InjectionUtil.detectAnnotatedMethod(paClass, PreUndeploy.class);

    if(preUndeployMethod != null) {
      try {
        processApplication.execute(new Callable<Void>() {
          @Override
          public Void call() throws Exception {
            preUndeployMethod.invoke(processApplication.getRawObject(), getInjections(preUndeployMethod));
            return null;
          }
        });
      } catch(Exception e) {
        throw new RuntimeException("Exception while invoking the @PreUndeploy method ", e);
      }
    }
  }

}
 

protected void invokePostDeploy(final ProcessApplicationInterface processApplication) throws ClassNotFoundException, StartException {
  Class<?> paClass = getPaClass(postDeployDescription);
  final Method postDeployMethod = InjectionUtil.detectAnnotatedMethod(paClass, PostDeploy.class);

  if(postDeployMethod != null) {
    try {
      processApplication.execute(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
          postDeployMethod.invoke(processApplication.getRawObject(), getInjections(postDeployMethod));
          return null;
        }
      });
    }catch(Exception e) {
      throw new StartException("Exception while invoking the @PostDeploy method ", e);
    }
  }

}
 

protected static VariableSerializers getCurrentPaSerializers() {
  if (Context.getCurrentProcessApplication() != null) {
    ProcessApplicationReference processApplicationReference = Context.getCurrentProcessApplication();
    try {
      ProcessApplicationInterface processApplicationInterface = processApplicationReference.getProcessApplication();

      ProcessApplicationInterface rawPa = processApplicationInterface.getRawObject();
      if (rawPa instanceof AbstractProcessApplication) {
        return ((AbstractProcessApplication) rawPa).getVariableSerializers();
      }
      else {
        return null;
      }
    } catch (ProcessApplicationUnavailableException e) {
      throw LOG.cannotDeterminePaDataformats(e);
    }
  }
  else {
    return null;
  }
}
 

protected void invokePreUndeploy(final ProcessApplicationInterface processApplication) throws ClassNotFoundException {
  if(preUndeployDescription != null) {
    Class<?> paClass = getPaClass(preUndeployDescription);
    final Method preUndeployMethod = InjectionUtil.detectAnnotatedMethod(paClass, PreUndeploy.class);

    if(preUndeployMethod != null) {
      try {
        processApplication.execute(new Callable<Void>() {
          @Override
          public Void call() throws Exception {
            preUndeployMethod.invoke(processApplication.getRawObject(), getInjections(preUndeployMethod));
            return null;
          }
        });
      } catch(Exception e) {
        throw new RuntimeException("Exception while invoking the @PreUndeploy method ", e);
      }
    }
  }

}
 

protected void invokePostDeploy(final ProcessApplicationInterface processApplication) throws ClassNotFoundException, StartException {
  Class<?> paClass = getPaClass(postDeployDescription);
  final Method postDeployMethod = InjectionUtil.detectAnnotatedMethod(paClass, PostDeploy.class);

  if(postDeployMethod != null) {
    try {
      processApplication.execute(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
          postDeployMethod.invoke(processApplication.getRawObject(), getInjections(postDeployMethod));
          return null;
        }
      });
    }catch(Exception e) {
      throw new StartException("Exception while invoking the @PostDeploy method ", e);
    }
  }

}
 

protected void notifyTaskListener(DelegateTask task) throws Exception {
  ProcessApplicationReference processApp = Context.getCurrentProcessApplication();
  try {
    ProcessApplicationInterface processApplication = processApp.getProcessApplication();
    TaskListener taskListener = processApplication.getTaskListener();
    if(taskListener != null) {
      taskListener.notify(task);

    } else {
      LOG.paDoesNotProvideTaskListener(processApp.getName());

    }
  } catch (ProcessApplicationUnavailableException e) {
    // Process Application unavailable => ignore silently
    LOG.cannotInvokeListenerPaUnavailable(processApp.getName(), e);
  }
}
 

protected void notifyExecutionListener(DelegateExecution execution) throws Exception {
  ProcessApplicationReference processApp = Context.getCurrentProcessApplication();
  try {
    ProcessApplicationInterface processApplication = processApp.getProcessApplication();
    ExecutionListener executionListener = processApplication.getExecutionListener();
    if(executionListener != null) {
      executionListener.notify(execution);

    } else {
      LOG.paDoesNotProvideExecutionListener(processApp.getName());

    }
  } catch (ProcessApplicationUnavailableException e) {
    // Process Application unavailable => ignore silently
    LOG.cannotInvokeListenerPaUnavailable(processApp.getName(), e);
  }
}
 

protected void executeScript(final ProcessApplicationInterface processApplication) {
  processEngineConfiguration.getCommandExecutorTxRequired()
    .execute(new Command<Void>() {
      public Void execute(CommandContext commandContext) {
        return Context.executeWithinProcessApplication(new Callable<Void>() {

          public Void call() throws Exception {
            ScriptingEngines scriptingEngines = processEngineConfiguration.getScriptingEngines();
            ScriptEngine scriptEngine = scriptingEngines.getScriptEngineForLanguage(SCRIPT_LANGUAGE);

            SourceExecutableScript script = createScript(SCRIPT_LANGUAGE, SCRIPT);

            ScriptingEnvironment scriptingEnvironment = processEngineConfiguration.getScriptingEnvironment();
            scriptingEnvironment.execute(script, null, null, scriptEngine);

            return null;
          }
        }, processApplication.getReference());
      }
    });
}
 

protected ELResolver getElResolverDelegate() {

    ProcessApplicationReference processApplicationReference = Context.getCurrentProcessApplication();
    if(processApplicationReference != null) {

      try {
        ProcessApplicationInterface processApplication = processApplicationReference.getProcessApplication();
        return processApplication.getBeanElResolver();

      } catch (ProcessApplicationUnavailableException e) {
        throw new ProcessEngineException("Cannot access process application '"+processApplicationReference.getName()+"'", e);
      }

    } else {
      return new BeanELResolver();
    }

  }
 

protected ELResolver getElResolverDelegate() {

    ProcessApplicationReference processApplicationReference = Context.getCurrentProcessApplication();
    if(processApplicationReference != null) {

      try {
        ProcessApplicationInterface processApplication = processApplicationReference.getProcessApplication();
        return processApplication.getElResolver();

      } catch (ProcessApplicationUnavailableException e) {
        throw new ProcessEngineException("Cannot access process application '"+processApplicationReference.getName()+"'", e);
      }

    } else {
      return null;
    }

  }
 

protected Map<String, List<ExecutableScript>> getPaEnvScripts(ProcessApplicationReference pa) {
  try {
    ProcessApplicationInterface processApplication = pa.getProcessApplication();
    ProcessApplicationInterface rawObject = processApplication.getRawObject();

    if (rawObject instanceof AbstractProcessApplication) {
      AbstractProcessApplication abstractProcessApplication = (AbstractProcessApplication) rawObject;
      return abstractProcessApplication.getEnvironmentScripts();
    }
    return null;
  }
  catch (ProcessApplicationUnavailableException e) {
    throw new ProcessEngineException("Process Application is unavailable.", e);
  }
}
 

@Override
public void init(BundleContext context, DependencyManager manager)
		throws Exception {

	RuntimeContainerDelegate.INSTANCE.set(new OSGiRuntimeContainerDelegate(
			context));
	manager.add(createComponent().setImplementation(
			ProcessApplicationDeployer.class).add(
			createServiceDependency().setService(
					ProcessApplicationInterface.class).setCallbacks(
					"addProcessApplication", "removeProcessApplication")));
}
 

/**
 * <p> Stops a process application. Exceptions are logged but not re-thrown).
 *
 * @param processApplicationReference
 */
protected void stopProcessApplication(ProcessApplicationReference processApplicationReference) {

  try {
    // unless the user has overridden the stop behavior,
    // this causes the process application to remove its services
    // (triggers nested undeployment operation)
    ProcessApplicationInterface processApplication = processApplicationReference.getProcessApplication();
    processApplication.undeploy();
  }
  catch(Throwable t) {
    LOG.exceptionWhileStopping("Process Application", processApplicationReference.getName(), t);
  }

}
 

protected ScriptEngine getScriptEngineFromPa(final String name, final ProcessApplicationInterface processApplication) {
  return processEngineConfiguration.getCommandExecutorTxRequired()
    .execute(new Command<ScriptEngine>() {
      public ScriptEngine execute(CommandContext commandContext) {
        return Context.executeWithinProcessApplication(new Callable<ScriptEngine>() {

          public ScriptEngine call() throws Exception {
            return getScriptEngine(name);
          }
        }, processApplication.getReference());
      }
    });
}
 

public ProcessApplicationInterface getValue() throws IllegalStateException, IllegalArgumentException {
  try {
    return reference.getProcessApplication();
    
  } catch (ProcessApplicationUnavailableException e) {
    throw new IllegalStateException("Process application '"+reference.getName()+"' is not unavailable.", e);
  }
}
 

public ProcessApplicationInterface getValue() throws IllegalStateException, IllegalArgumentException {
  try {
    return reference.getProcessApplication();
    
  } catch (ProcessApplicationUnavailableException e) {
    throw new IllegalStateException("Process application '"+reference.getName()+"' is not unavailable.", e);
  }
}
 

@SuppressWarnings("resource")
@Override
public void postProcessApplicationUndeploy(ProcessApplicationInterface processApplication) {
  // some tests deploy multiple PAs. => only clean DB after last PA is undeployed
  // if the deployment fails for example during parsing the deployment counter was not incremented
  // so we have to check if the counter is already zero otherwise we go into the negative values
  // best example is TestWarDeploymentWithBrokenBpmnXml in integration-test-engine test suite
  if(counter.get() == 0 || counter.decrementAndGet() == 0) {

    final ProcessEngine defaultProcessEngine = BpmPlatform.getDefaultProcessEngine();
    try {
      logger.log(Level.INFO, "=== Ensure Clean Database ===");
      ManagementServiceImpl managementService = (ManagementServiceImpl) defaultProcessEngine.getManagementService();
      PurgeReport report = managementService.purge();

      if (report.isEmpty()) {
        logger.log(Level.INFO, "Clean DB and cache.");
      } else {
        StringBuilder builder = new StringBuilder();

        DatabasePurgeReport databasePurgeReport = report.getDatabasePurgeReport();
        if (!databasePurgeReport.isEmpty()) {
          builder.append(DATABASE_NOT_CLEAN).append(databasePurgeReport.getPurgeReportAsString());
        }

        CachePurgeReport cachePurgeReport = report.getCachePurgeReport();
        if (!cachePurgeReport.isEmpty()) {
          builder.append(CACHE_IS_NOT_CLEAN).append(cachePurgeReport.getPurgeReportAsString());
        }
        logger.log(Level.INFO, builder.toString());
      }
    }
    catch(Throwable e) {
      logger.log(Level.SEVERE, "Could not clean DB:", e);
    }
  }

}
 

protected ScriptEngine getPaScriptEngine(String language, ProcessApplicationReference pa) {
  try {
    ProcessApplicationInterface processApplication = pa.getProcessApplication();
    ProcessApplicationInterface rawObject = processApplication.getRawObject();

    if (rawObject instanceof AbstractProcessApplication) {
      AbstractProcessApplication abstractProcessApplication = (AbstractProcessApplication) rawObject;
      return abstractProcessApplication.getScriptEngineForName(language, enableScriptEngineCaching);
    }
    return null;
  }
  catch (ProcessApplicationUnavailableException e) {
    throw new ProcessEngineException("Process Application is unavailable.", e);
  }
}
 

/**
 * lookup a proxy object representing the invoked business view of this component.
 */
protected ProcessApplicationInterface lookupSelfReference() {

  try {
    InitialContext ic = new InitialContext();
    SessionContext sctxLookup = (SessionContext) ic.lookup(EJB_CONTEXT_PATH);
    return sctxLookup.getBusinessObject(getBusinessInterface());
  }
  catch (NamingException e) {
    throw LOG.ejbPaCannotLookupSelfReference(e);
  }

}
 

@Override
public void postProcessApplicationDeploy(ProcessApplicationInterface processApplication) {
  ProcessApplicationInterface rawPa = processApplication.getRawObject();
  if (rawPa instanceof AbstractProcessApplication) {
    initializeVariableSerializers((AbstractProcessApplication) rawPa);
  }
  else {
    LOG.logNoDataFormatsInitiailized("process application data formats", "process application is not a sub class of " + AbstractProcessApplication.class.getName());
  }
}
 

public ProcessApplicationInterface getProcessApplication() throws ProcessApplicationUnavailableException {
  try {
    // check whether process application is still deployed
    selfReference.getName();
  }
  catch(EJBException e) {
    throw LOG.processApplicationUnavailableException(processApplicationName, e);
  }
  return selfReference;
}
 

public void removeProcessApplication(ServiceReference<ProcessApplicationInterface> reference, ProcessApplicationInterface service) {
  service.undeploy();
}
 

@Override
public void postProcessApplicationDeploy(ProcessApplicationInterface processApplication) {
}
 

@Override
public ProcessApplicationInterface getProcessApplication() throws ProcessApplicationUnavailableException {
  return application;
}
 

public InjectedValue<ProcessApplicationInterface> getNoViewProcessApplication() {
  return noViewProcessApplication;
}
 

protected void notifyBpmPlatformPlugins(BpmPlatformPlugins value, ProcessApplicationInterface processApplication) {
  for (BpmPlatformPlugin plugin : value.getPlugins()) {
    plugin.postProcessApplicationDeploy(processApplication);
  }
}
 

public OSGiProcessApplicationReference(ProcessApplicationInterface application, String name) {
  this.application = application;
  this.name = name;
}
 

public InjectedValue<ProcessApplicationInterface> getNoViewProcessApplication() {
  return noViewProcessApplication;
}
 

public InjectedValue<ProcessApplicationInterface> getNoViewProcessApplication() {
  return noViewProcessApplication;
}