Camunda Automation Platform 7.16.0 Released

We are excited to announce that Camunda Automation Platform 7.16.0 is now available, including many new features.

Here are some of the highlights:

• Cockpit: Correlate a message
• Cockpit: Set variables during process instance migration
• Cockpit: Drill down into call activities
• Quarkus 2 extension
• Set up and migrate your database schema with Liquibase
• GraalJS for Javascript execution
• Dedicate Job Executors to priority ranges
• Camunda Forms in Tasklist
• Complete OpenAPI specification
• New supported environments
• Retired supported environments
• Revamped continuous integration

You can download Camunda Automation Platform 7.16.0 or run it with Docker.

Also included in the release:

• Camunda Platform Assert 11.0.0, 12.0.0, and 13.0.0 for convenient testing of processes in Java. Check the version compatibility matrix for which release fits your setup.
• Javascript External Task Client 2.1.1 for connecting Javascript workers to Camunda Automation Platform.

For a complete list of the changes, please check out the release notes. For patched security vulnerabilities, see our security notices.

If you want to dig deeper, you can find the source code on GitHub.

Cockpit: Correlate a Message

This UI feature is only available in the enterprise edition of the Camunda Platform. You can test it out now with a free trial.

When a process instance waits for a message, you can use message correlation to deliver the message and continue the flow. We are introducing a new Cockpit batch operation to correlate messages asynchronously. 

This allows you to:

• Send a message to a process instance directly from the BPMN diagram
• Send the same message to thousands of process instances in just a few clicks

This feature is also available in the REST API and the Java API:

RuntimeService runtimeService = processEngine.getRuntimeService();
ProcessInstanceQuery processInstanceQuery = runtimeService.createProcessInstanceQuery()
  .processDefinitionKey("message-process");
Batch batch = runtimeService.createMessageCorrelationAsync("my-message")
  .processInstanceQuery(processInstanceQuery)
  .setVariable("var1", "val1")
  .setVariable("var2", "val2")
  .correlateAllAsync();

Cockpit: Set Variables During Process Instance Migration

This UI feature is only available in the enterprise edition of the Camunda Platform. You can test it out now with a free trial.

Sometimes, there is room to improve a process model deployed to the process engine that has running process instances. Process instance migration does the job of moving the instances from one version to the next. In the new version, your process might require more data to function properly. Camunda Automation Platform 7.16.0 extends the migration feature to set variables when performing a migration operation.

This feature is also available in the REST API and the Java API:

Map<String, Object> variables = Variables.putValue("my-variable-name", "my-variable-value");MigrationPlan migrationPlan = processEngine.getRuntimeService()
  .mapEqualActivities()
  .setVariables(variables) // variables to be set to the process instances' scope
  .build();

List<String> processInstanceIds = ...;

runtimeService.newMigration(migrationPlan)
  .processInstanceIds(processInstanceIds)
  .executeAsync();

Cockpit: Drill Down Into Call Activities

If you use BPMN call activities for decomposing your processes, you can now drill into call activities within Cockpit. Click the badge on the call activity or check the Called Process Definitions tab for an overview of all your call activities.

This feature is also available in the REST API and the Java API:

ProcessDefinition callingProcess = ...;
Collection<CalledProcessDefinition> calledProcesses = processEngine.getRepositoryService()
  .getStaticCalledProcessDefinitions(callingProcess .getId());

for (CalledProcessDefinition calledProcess : calledProcesses) {
  System.out.println(calledProcess.getId());
}

Quarkus 2 Extension

The Camunda Quarkus extension integrates Camunda Platform with the Quarkus framework. Adding a process engine to your Quarkus application is as simple as these three steps:

1. Add a Maven dependency:

<dependency>  <groupId>org.camunda.bpm.quarkus</groupId>
  <artifactId>camunda-bpm-quarkus-engine</artifactId>
  <version>7.16.0</version>
</dependency>

2. Point the process engine to its database schema in application.properties:

quarkus.camunda.datasource=custom-datasource
quarkus.datasource.custom-datasource.username=postgres
quarkus.datasource.custom-datasource.password=postgres

quarkus.datasource.custom-datasource.db-kind=postgresql
quarkus.datasource.custom-datasource.jdbc.url=jdbc:postgresql://localhost:5432/process-engine

3. Inject the process engine and its services into your CDI beans:

@Named
@Dependent
public class MyBean {

  @Inject
  public RepositoryService repositoryService;

  @Inject
  public RuntimeService runtimeService;

  public void deployProcess(@Observes CamundaEngineStartupEvent startupEvent) {
    Deployment deployment = repositoryService.createDeployment()
      .enableDuplicateFiltering(true)
      .addClasspathResource("bpmn/process.bpmn")
      .deploy();
  }

  public void startProcess() {
    <code>runtimeService.startProcessInstanceByKey("my-process");
  }
}

Have a look at our readily executable examples for inspiration on what you can do with the extension. Read up in the Quarkus Extension User Guide on how it works in the details.

Set Up and Migrate Your Database Schema with Liquibase

Camunda Automation 7.16.0 integrates with Liquibase to ease setting up the Camunda database schema and migrating to future Camunda versions. The Camunda schema can be created in four steps:

1. Download Liquibase CLI
2. In your Camunda download, go to the directory sql/liquibase
3. Create a file liquibase.properties with your database connection details, for example:

url=jdbc:postgresql://localhost:5432/process-engine
username=camunda
password=camunda

(Hint: Follow the Liquibase tutorial for your database to get all the details right)

4. Run liquibase --changeLogFile=camunda-changelog.xml update

To update the schema to any future Camunda version, simply download the new Camunda distribution and re-run the Liquibase command. Read all about the new Liquibase integration in the Liquibase installation and Liquibase update documentation.

Note that migrating from a lower Camunda Automation Platform version to 7.16.0 is not possible with Liquibase and must be done with the traditional approach.

GraalJS for Javascript Execution

Java 15 removes the Nashorn Javascript engine and you can no longer use it to run Javascript in your BPMN processes and DMN decisions. As a replacement, we are integrating GraalJS, the Javascript engine implementation from the GraalVM project.

If you use the Camunda Run, Tomcat, WildFly, Weblogic, or Websphere distributions, GraalJS is configured out of the box. In case you use an embedded process engine in your Java application (for example if you are using the Spring Boot starter), simply add the GraalJS dependencies to your project. No further configuration required. Read all the details in our update guide.

Camunda integrates and configures GraalJS with a high degree of Nashorn-compatibility settings so that GraalJS acts as a full drop-in replacement in most cases. However, if you prefer using Nashorn (and your JDK still has it), you can set the process engine configuration property scriptEngineNameJavaScript to nashorn.

Dedicate Job Executors to Priority Ranges

If you have high- and low-priority jobs, you may want to ensure that the low-priority jobs never take up all the execution resources. With this release, you can achieve that by setting up two process engines with job executors, each dedicated to their own priority range.

In the process engine configuration, set the property jobExecutorPriorityRangeMin to the lower bound and jobExecutorPriorityRangeMax to the upper bound that you want the job executor to work on. Job acquisition will then only pick up jobs that fall into the range, reserving the execution threads accordingly.

Camunda Forms in Tasklist

In Camunda Automation Platform 7.16.0, you can use all the new Camunda Forms features that come with Camunda Modeler 4.10. Check out the Camunda Modeler 4.10 release blog post for details.

In addition, you can now bind a user task to forms from other deployments. Reference a form by one of the following strategies:

• The form is contained in the same deployment
• The latest version of the form with the given ID
• A specific version of the form with the given ID

This allows you to more flexibly reuse forms in different BPMN processes as well as iterate over forms more quickly than over BPMN processes.

Complete OpenAPI Specification

With Camunda Automation Platform 7.16.0, the OpenAPI specification of our REST API covers all endpoints except those that are related to CMMN. Generate a REST client in your favorite programming language today or explore the Camunda REST API with Swagger UI.

New Supported Environments

• WildFly Application Server 23.0
• JBoss EAP 7.4
• Azure SQL (SQL Server on Azure Virtual Machines, Azure SQL Managed Instance, Azure SQL Database) – See our Azure SQL documentation for how to use Azure SQL correctly with Camunda
• Java 15

Retired Supported Environments

• WildFly 12
• JBoss EAP 6.4
• MySQL 5.6
• DB2 10.5
• SQL Server 2012
• Oracle 18

You can always check out our currently supported environments in the Camunda documentation. 

Revamped Continuous Integration 

Under the hood we made our continuous integration (CI) infrastructure future-proof by migrating from Jenkins freestyle jobs to Jenkins declarative pipelines. Our CI is at the core of why we can deliver a high-quality product after years of ongoing development while integrating with a vast range of different technologies.

Watch the Camunda Platform 7.16.0 Release Webinar

If you missed it, be sure to watch the Camunda Platform 7.16.0 Release webinar on demand.

Your Feedback Matters!

With every release, we strive to improve the Camunda Platform, and we rely on your feedback. Feel free to share your ideas and suggestions with us via the Camunda User Forum.