Camunda BPM 7.2.0 Final Released

CMMN allows modeling Cases. A case allows humans to do work in a more or less structured way in order to achieve something. Classic examples where case management is applied are Credit Application, Customer Support Management, Document Management, and so on.

The following is a simple Example of a Credit Application Case modeled in CMMN:

• Stage
• Human Task, Process Task, Case Task
• Sentries
• Milestones

The implementation is provided through the process engine Java API as well as the REST API.

• Reduction of dead locks due to consistent flush ordering. Before, the ordering of the database flush (INSERTS, UPDATES, DELETES) at the end of the transaction could lead to deadlocks, the new implementation enforces that any two transactions working on the same pair of entities will flush modifications in the same order.
• 1st level cache reuse: the first level cache will always be consistent with the database at the end of a transaction which allows us to reuse it in subsequent transactions. The cache can currently be reused in sequences of asynchronous continuations executed by the Job Executor. At the end of a transaction we flush the deltas and then reuse the cache in the next transaction, instead of throwing the memory state away and re-fetching everything from the database. This makes asynchronous continuations a lot more light-weight.
• In the future:
  •  it may be easier to support alternative databases such as Mongo DB. We already experimented with Hazelcase (in-memory data grid) as persistence provider and it worked out.
  • we will be able to remove the limitation induced by the fact that atomic operations are executed recursively: the stack size grows limiting the number of activity instance which can be executed in a single transaction. We could now remove this in the next release if users should need this.

Next, the scalability of the Job Executor (responsible for asynchronous processing) has been improved in 7.2. Before only 1-2 nodes could consume effectively from the queue, now users can now have larger clusters.


Custom history levels: it is now possible to implement a custom history level which allows users to determine in a very fine granular way what data should be logged. This is useful for users with extreme amounts of process instances and who need to control the number of history events produced.

CustomerData customerData = new CustomerData();

execution.setVariable("customerData", objectValue(customerData)
  .serializationDataFormat(SerializationDataFormats.JSON)
  .create());

We also introduce the Spin Dataformat API which provides support for parsing, writing, querying and mapping Xml and JSON data. The Spin Dataformat API can be used in Expression Language as well, allowing users to directly execute XPath or JsonPath when configuring sequence flow conditions:

${XML(customer).xPath("/customer/address/postcode").element().textContent() == "1234"}

The Spin Dataformat API allows users to extend it with custom functionality or implement their own dataformats. Source code for the Spin Dataformat API is available on GitHub.

• Compilation: the process engine can be configured to compile (and cache the compiled scripts) these languages. This improves performance.
• Scripts can now be used everywhere where expression language or custom Java code can be used, including Execution Listeners, Task Listeners, Sequence Flow conditions.

What makes connectors different from plain  Java delegate implementations (which you already know)?

1. The most important difference is that connectors declare their input / output parameters. This will make it possible for us to build tooling which allows users to configure the input / output parameters of arbitrary connectors. Connector I/O is configured using variable I/O mapping (also new 🙂 )
2. Connectors provide a simple Interceptor API which allows users to customize connectors. This way they can implement cross cutting concerns such as logging, authentication, encryption etc.
3. Connectors provide a more Request / Response oriented API. We may also support asynchronous connectors in the future.