org.camunda.bpm.engine.ProcessEngines Java Examples

private void setProcessEngineName(SpringProcessEngineConfiguration configuration) {
  String processEngineName = StringUtils.trimAllWhitespace(camundaBpmProperties.getProcessEngineName());
  if (!StringUtils.isEmpty(processEngineName) && !processEngineName.contains("-")) {

    if (camundaBpmProperties.getGenerateUniqueProcessEngineName()) {
      if (!processEngineName.equals(ProcessEngines.NAME_DEFAULT)) {
        throw new RuntimeException(String.format("A unique processEngineName cannot be generated "
          + "if a custom processEngineName is already set: %s", processEngineName));
      }
      processEngineName = CamundaBpmProperties.getUniqueName(camundaBpmProperties.UNIQUE_ENGINE_NAME_PREFIX);
    }

    configuration.setProcessEngineName(processEngineName);
  } else {
    logger.warn("Ignoring invalid processEngineName='{}' - must not be null, blank or contain hyphen", camundaBpmProperties.getProcessEngineName());
  }
}
 

@Override
protected void closeDownProcessEngine() {
  super.closeDownProcessEngine();
  final ProcessEngine otherProcessEngine = ProcessEngines.getProcessEngine(PROCESS_ENGINE_NAME);
  if (otherProcessEngine != null) {

    ((ProcessEngineConfigurationImpl)otherProcessEngine.getProcessEngineConfiguration()).getCommandExecutorTxRequired().execute(new Command<Void>() {
      public Void execute(CommandContext commandContext) {

        List<Job> jobs = otherProcessEngine.getManagementService().createJobQuery().list();
        if (jobs.size() > 0) {
          assertEquals(1, jobs.size());
          String jobId = jobs.get(0).getId();
          commandContext.getJobManager().deleteJob((JobEntity) jobs.get(0));
          commandContext.getHistoricJobLogManager().deleteHistoricJobLogByJobId(jobId);
        }

        return null;
      }
    });

    otherProcessEngine.close();
    ProcessEngines.unregister(otherProcessEngine);
  }
}
 

@Override
public void close() {

  ProcessEngines.unregister(this);

  if(processEngineConfiguration.isMetricsEnabled()) {
    processEngineConfiguration.getDbMetricsReporter().stop();
  }

  if ((jobExecutor != null)) {
    // unregister process engine with Job Executor
    jobExecutor.unregisterProcessEngine(this);
  }

  commandExecutorSchemaOperations.execute(new SchemaOperationProcessEngineClose());

  processEngineConfiguration.close();

  LOG.processEngineClosed(name);
}
 

@SuppressWarnings({ "unchecked", "rawtypes" })
@Test
public void deleteEngine() throws Throwable{
  String engineName = "TestEngine";
  Bundle bundle = mock(Bundle.class);
  // mock stuff the BundleDelegatingClassLoader does/needs
  mockGetResource(bundle);
  mockLoadClass(bundle);

  BundleContext bundleContext = mock(BundleContext.class);
  when(bundle.getBundleContext()).thenReturn(bundleContext);
  ServiceRegistration registrationMock = mock(ServiceRegistration.class);
  when(bundleContext.registerService(eq(ProcessEngine.class), any(ProcessEngine.class), any(Dictionary.class))).thenReturn(registrationMock);
  ManagedProcessEngineFactoryImpl factory = new ManagedProcessEngineFactoryImpl(bundle);
  Hashtable<String, String> properties = createEngineProperties(engineName);
  factory.updated("id", properties);
  
  factory.deleted("id");
  
  verify(registrationMock, times(1)).unregister();
  assertThat(ProcessEngines.getProcessEngine(engineName), is(nullValue()));
}
 

@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void updatedNewConfiguration() throws Exception {
  String engineName = "TestEngine";
  Bundle bundle = mock(Bundle.class);
  // mock stuff the BundleDelegatingClassLoader does/needs
  mockGetResource(bundle);
  mockLoadClass(bundle);
  BundleContext bundleContext = mock(BundleContext.class);
  when(bundle.getBundleContext()).thenReturn(bundleContext);
  when(bundleContext.registerService(eq(ProcessEngine.class), any(ProcessEngine.class), any(Dictionary.class))).thenReturn(mock(ServiceRegistration.class));
  ManagedProcessEngineFactoryImpl factory = new ManagedProcessEngineFactoryImpl(bundle);
  Hashtable<String, String> properties = createEngineProperties(engineName);

  factory.updated("id", properties);

  ArgumentCaptor<Dictionary> propsCapture = ArgumentCaptor.forClass(Dictionary.class);
  ArgumentCaptor<ProcessEngine> engineCapture = ArgumentCaptor.forClass(ProcessEngine.class);

  verify(bundleContext, times(1)).registerService(eq(ProcessEngine.class), engineCapture.capture(), propsCapture.capture());
  assertThat(engineCapture.getValue(), is(notNullValue()));
  assertThat(propsCapture.getValue().get("process-engine-name"), is((Object) engineName));
  assertThat(ProcessEngines.getProcessEngine(engineName), is(notNullValue()));
}
 

public static void main(String[] args) {

    // start process engine
    StandaloneInMemProcessEngineConfiguration processEngineConfiguration = new StandaloneInMemProcessEngineConfiguration();
    processEngineConfiguration.setProcessEngineName(ProcessEngines.NAME_DEFAULT);

    // add plugins
    List<ProcessEnginePlugin> processEnginePlugins = processEngineConfiguration.getProcessEnginePlugins();
    processEnginePlugins.add(new DebuggerPlugin());
    processEnginePlugins.add(new SpinProcessEnginePlugin());
    processEnginePlugins.add(new ConnectProcessEnginePlugin());

    processEngineConfiguration.buildProcessEngine();

    DebugSessionFactory.getInstance().setSuspend(false);

    // start debug server
    DebugWebsocket debugWebsocket = null;
    try {

      // configure & start the server
      debugWebsocket = new DebugWebsocketConfiguration()
        .port(9090)
        .startServer();

      // block
      debugWebsocket.waitForShutdown();

    } finally {
      if(debugWebsocket != null) {
        debugWebsocket.shutdown();
      }
    }

  }
 

protected void init() {
  if (executed)
    throw new IllegalStateException("Scenarios may use execute() just once per Scenario.run(). " +
        "Please create a new Scenario.run().");
  executed = true;
  if (processEngine == null) {
    Map<String, ProcessEngine> processEngines = ProcessEngines.getProcessEngines();
    if (processEngines.size() == 1) {
      init(processEngines.values().iterator().next());
    } else {
      String message = processEngines.size() == 0 ? "No ProcessEngine found to be " +
          "registered with " + ProcessEngines.class.getSimpleName() + "!"
          : String.format(processEngines.size() + " ProcessEngines initialized. " +
          "Explicitely initialise engine by calling " + ScenarioImpl.class.getSimpleName() +
          "(scenario, engine)");
      throw new IllegalStateException(message);
    }
  }
}
 

private void setProcessEngineName(SpringProcessEngineConfiguration configuration) {
  String processEngineName = StringUtils.trimAllWhitespace(camundaBpmProperties.getProcessEngineName());
  if (!StringUtils.isEmpty(processEngineName) && !processEngineName.contains("-")) {

    if (camundaBpmProperties.getGenerateUniqueProcessEngineName()) {
      if (!processEngineName.equals(ProcessEngines.NAME_DEFAULT)) {
        throw new RuntimeException(String.format("A unique processEngineName cannot be generated "
          + "if a custom processEngineName is already set: %s", processEngineName));
      }
      processEngineName = CamundaBpmProperties.getUniqueName(camundaBpmProperties.UNIQUE_ENGINE_NAME_PREFIX);
    }

    configuration.setProcessEngineName(processEngineName);
  } else {
    logger.warn("Ignoring invalid processEngineName='{}' - must not be null, blank or contain hyphen", camundaBpmProperties.getProcessEngineName());
  }
}
 

@Override
@Test
public void testEngineName()
{
  assertThat(processEngine.getName()).isNotEqualTo(ProcessEngines.NAME_DEFAULT);
  assertThat(processEngine.getName()).containsPattern("processEngine\\w{10}");
}
 

public static void main(String[] args) {
  ProcessEngineImpl processEngine = (ProcessEngineImpl) ProcessEngines.getDefaultProcessEngine();
  CommandExecutor commandExecutor = processEngine.getProcessEngineConfiguration().getCommandExecutorTxRequired();
  commandExecutor.execute(new Command<Object> (){
    public Object execute(CommandContext commandContext) {
      commandContext
        .getSession(PersistenceSession.class)
        .dbSchemaDrop();
      return null;
    }
  });
  processEngine.close();
}
 

public static void main(String[] args) {
  ProcessEngineImpl processEngine = (ProcessEngineImpl) ProcessEngines.getDefaultProcessEngine();
  CommandExecutor commandExecutor = processEngine.getProcessEngineConfiguration().getCommandExecutorTxRequired();
  commandExecutor.execute(new Command<Object> (){
    public Object execute(CommandContext commandContext) {
      commandContext
        .getSession(PersistenceSession.class)
        .dbSchemaPrune();
      return null;
    }
  });
}
 

@Test
public void testConsecutiveEngineBootstrapHistoryCleanupJobReconfiguration() {

  // given
  // create history cleanup job
  ProcessEngineConfiguration
    .createProcessEngineConfigurationFromResource("org/camunda/bpm/engine/test/history/batchwindow.camunda.cfg.xml")
    .buildProcessEngine()
    .close();

  // when
  // suspend history cleanup job
  ProcessEngineConfiguration
    .createProcessEngineConfigurationFromResource("org/camunda/bpm/engine/test/history/no-batchwindow.camunda.cfg.xml")
    .buildProcessEngine()
    .close();

  // then
  // reconfigure history cleanup job
  ProcessEngineConfiguration processEngineConfiguration = ProcessEngineConfiguration
    .createProcessEngineConfigurationFromResource("org/camunda/bpm/engine/test/history/batchwindow.camunda.cfg.xml");
  processEngineConfiguration.setProcessEngineName(ENGINE_NAME);
  ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();

  assertNotNull(ProcessEngines.getProcessEngine(ENGINE_NAME));

  closeProcessEngine(processEngine);
}
 

public void testProcessEngineInfo() {

    List<ProcessEngineInfo> processEngineInfos = ProcessEngines.getProcessEngineInfos();
    assertEquals(1, processEngineInfos.size());

    ProcessEngineInfo processEngineInfo = processEngineInfos.get(0);
    assertNull(processEngineInfo.getException());
    assertNotNull(processEngineInfo.getName());
    assertNotNull(processEngineInfo.getResourceUrl());

    ProcessEngine processEngine = ProcessEngines.getProcessEngine(ProcessEngines.NAME_DEFAULT);
    assertNotNull(processEngine);
  }
 

@Test
public void testEngineRegistration()
{
  // do
  ProcessEngine registeredEngine = ProcessEngines.getProcessEngine("default");
  assertThat(registeredEngine).isNotSameAs(processEngine);
}
 

@Override
@Test
public void testEngineName()
{
  assertThat(processEngine.getName()).isNotEqualTo(ProcessEngines.NAME_DEFAULT);
  assertThat(processEngine.getName()).containsPattern("processEngine\\w{10}");
}
 

@Override
@Test
public void testEngineName()
{
  assertThat(processEngine.getName()).isNotEqualTo(ProcessEngines.NAME_DEFAULT);
  assertThat(processEngine.getName()).containsPattern("processEngine\\w{10}");
}
 

@Override
@Test
public void testEngineName()
{
  assertThat(processEngine.getName()).isNotEqualTo(ProcessEngines.NAME_DEFAULT);
  assertThat(processEngine.getName()).containsPattern("processEngine\\w{10}");
}
 

@Override
@Test
public void testEngineName()
{
  assertThat(processEngine.getName()).isNotEqualTo(ProcessEngines.NAME_DEFAULT);
  assertThat(processEngine.getName()).containsPattern("processEngine\\w{10}");
}
 

@Override
@Test
public void testEngineName()
{
  assertThat(processEngine.getName()).isNotEqualTo(ProcessEngines.NAME_DEFAULT);
  assertThat(processEngine.getName()).containsPattern("processEngine\\w{10}");
}
 

@Override
@Test
public void testEngineName()
{
  assertThat(processEngine.getName()).isNotEqualTo(ProcessEngines.NAME_DEFAULT);
  assertThat(processEngine.getName()).containsPattern("processEngine\\w{10}");
}
 

@Override
public ProcessEngine getDefaultProcessEngine() {
  ProcessEngine defaultProcessEngine = BpmPlatform.getDefaultProcessEngine();
  if(defaultProcessEngine != null) {
    return defaultProcessEngine;
  } else {
    return ProcessEngines.getDefaultProcessEngine(false);
  }
}
 

@Override
@Test
public void testEngineName()
{
  assertThat(processEngine.getName()).isNotEqualTo(ProcessEngines.NAME_DEFAULT);
  assertThat(processEngine.getName()).containsPattern("processEngine\\w{10}");
}
 

@Override
@Test
public void testEngineName()
{
  assertThat(processEngine.getName()).isNotEqualTo(ProcessEngines.NAME_DEFAULT);
  assertThat(processEngine.getName()).containsPattern("processEngine\\w{10}");
}
 

@Override
@Test
public void testEngineName()
{
  assertThat(processEngine.getName()).isNotEqualTo(ProcessEngines.NAME_DEFAULT);
  assertThat(processEngine.getName()).containsPattern("processEngine\\w{10}");
}
 

@Override
@Test
public void testEngineName()
{
  assertThat(processEngine.getName()).isNotEqualTo(ProcessEngines.NAME_DEFAULT);
  assertThat(processEngine.getName()).containsPattern("processEngine\\w{10}");
}
 

@Test
public void testEngineRegistration()
{
  // do
  ProcessEngine registeredEngine = ProcessEngines.getProcessEngine("default");
  assertThat(registeredEngine).isNotSameAs(processEngine);
}
 

@After
public void closeProcessEngines() {
  Iterator<ProcessEngine> iterator = createdProcessEngines.iterator();
  while (iterator.hasNext()) {
    ProcessEngine processEngine = iterator.next();
    processEngine.close();
    ProcessEngines.unregister(processEngine);
    iterator.remove();
  }
}
 

@Override
protected void finished(Description description) {
  deleteHistoryCleanupJob();
  processEngine.close();
  ProcessEngines.unregister(processEngine);
  processEngine = null;
}
 

protected void closeDownProcessEngine() {
  super.closeDownProcessEngine();
  if (otherProcessEngine != null) {
    otherProcessEngine.close();
    ProcessEngines.unregister(otherProcessEngine);
    otherProcessEngine = null;
  }
}
 

@Override
@Test
public void testEngineName()
{
  assertThat(processEngine.getName()).isNotEqualTo(ProcessEngines.NAME_DEFAULT);
  assertThat(processEngine.getName()).containsPattern("processEngine\\w{10}");
}