Flowable (V6) v6.6.0 Release Notes
Release Date: 2020-10-12 // over 3 years ago-
GENERAL
- 🚀 External worker tasks have been added to the BPMN and CMMN engine. This is a new paradigm that is available to execute service logic outside of the BPMN and CMMN engine. Until this release this could be done by pushing work to another service, like with using a HTTP task or send an event with the event registry task. The external worker task can be used to pull work from the BPMN and CMMN engine. This means that a service written in any language can pull for open external worker tasks over a dedicated external worker REST API, then execute the work, and finally complete the worker task to move the state of the process or case to the next state.
- ➕ Added support for future Java delegates to enable running service tasks and HTTP tasks actually in parallel. Until this release a parallel gateway with multiple outgoing sequence flows to a service task didn't run the synchronous service tasks really in parallel, they were still executed sequential. When these service tasks are made asynchronous and not exclusive, then they were executed in parallel by the async executor, but also in different transactions. With the new future service task support, it's now possible to run synchronous service tasks within the same transaction in parallel. The service tasks are executed in parallel on a thread pool and the future will wait until all service tasks are completed. More info is available in this https://blog.flowable.org/2020/08/06/true-parallel-service-task-execution-with-flowable/ blog post.
- ➕ Added a category property to jobs to be able to distinguish between different groups of jobs. This can also be used to enable the execution of only specific job categories in the BPMN or CMMN engine. In this way different micro services with an embedded Flowable engine using the same database can be configured to only execute jobs from a defined list of categories, as an example.
- 🚚 History jobs are now moved to the deadletter job table when the retries are exhausted. This ensures that the history job is always kept in the database.
- ✂ Removed the get current engine configuration from the CommandContextUtil classes of the Flowable engines because in an application where multiple engines are used it could not be guaranteed that the correct engine configuration was returned.
- ⚡️ JSON variable changes are now tracked when updated in expressions, scripts, delegate classes or Spring beans. This means that when updating a property like customer.name in a delegate class, the customer JSON variable will now automatically be updated.
- 👍 Extended the entity link support to also record grand parent entity links, which means the parent process of a task in a sub process for example.
- 🚀 When deploying via the BPMN, CMMN or DMN repository service the created deployment will have the parent deployment id set from its own deployment id.
- 🏗 The FlowableExpressionEnhancer has been removed. We have adapted the Expression parsing, so now functions are enhanced during the expression tree building. This is a lower level api and uses the new FlowableAstFunctionCreator.
BPMN
- 🚦 In and out parameters can be defined for signal events, similar to the existing in and out parameter support for call activities. By defining in parameters for a signal boundary event for example, variables can be set on the process instance scope from the signal payload data.
- ➕ Added support for triggerable service tasks with expressions.
- ➕ Added support for event registry backed receive task and intermediate catch event.
- ➕ Added support for JSON variables in web service tasks.
- For ordering activity instances that are part of the same Flowable transaction, a transaction order value has been added, which is a basic numeric value starting with 1 and incremented with 1 for every new activity instance.
CMMN
- ➕ Added support for case instance migration with defining for which plan item definitions the state needs to be changed. This also includes moving new plan item definitions to available state if needed.
- 👍 The Case task now supports in and out parameter mapping.
DMN
- 👌 Support for Decision services and DRD (Decision Requirement Diagram) has been added to the DMN engine. This enables the usage of a hierarchy of decision tables to calculate the output of a decision service in multiple decision tables.
APPS
- 💻 The UI Apps have been consolidated in one single Flowable UI App instead of 4 different applications. This makes the authentication and authorization logic less complex, makes the demo experience and installation experience easier and doesn't require you to switch between multiple browser tabs all the time. This means that now only 2 WAR files are provided in the Flowable Download, the Flowable UI app, that includes the Modeler, IDM, Admin and Task application together with the Flowable REST API and the second WAR file is the REST application that only includes the Flowable REST API. For more information you can read this https://blog.flowable.org/2020/10/07/flowable-6-instant-gratification/ blog post.
- 👌 Support for OAuth2 authentication is added to the Flowable UI App, with Keycloak as an example implementation, see also this https://blog.flowable.org/2020/10/12/whats-new-with-the-flowable-ui-apps/ blog post.
- ⚡️ Updated Docker images and Kubernetes Helm charts for the new Flowable UI app and with more configuration options. On the docker images the Spring boot applications are now started with a flowable user and not with the root user as before.
➕ ADDITIONAL
- 🚀 In this release an upgrade to Spring Boot 2.3.4 and Spring 5.2.9 was done.
Previous changes from v6.5.0
-
GENERAL
- ➕ Added a new Event Registry engine which provides functionality to use Flowable in event driven architectures and has out-of-the-box support for JMS, Apache Kafka and RabbitMQ. Events can be received by BPMN start events, boundary events and triggerable send event tasks. In CMMN receiving events is supported by event listeners and for starting new case instances. Both engines also provide a send event task to send out an event to the event adapter implementation.
- 🚀 To improve the support for running Flowable on multiple servers / nodes a new option was added to use a lock for creating the database schema and for executing the auto deployments at bootup. This ensures that when starting multiple servers / nodes at the same time, creating the database schema and doing the auto deployment of CMMN XML and BPMN XML files etc only happens on one server / node at the same time.
- 👷 A new Batch service was added to support executing multiple jobs in one batch, where each job is a batch part. The first usage of the Batch service is the support for batch process instance migration, but the Batch service is designed to support many use cases.
- 🌲 A first version of the Logging Session support has been added, which provides a full insight in the execution of case and process instances with all its child entities like tasks, variables, event subscriptions etc. This can be useful for debugging purpose, problem detection in production environments or for audit purposes.
- 👍 The variable service has been enriched to support java.time.Instant, java.time.LocalDate and java.time.LocalDateTime as additional variable types. When using these Object types as a variable they will not be stored as serializable anymore, but with a timestamp value and when used transformed into the correct Object type.
- 🛠 Various small bugfixes and improvements all around.
BPMN
- ➕ Added support for Event Registry start events to trigger starting a process instance with an incoming event.
- 👍 An Event Registry boundary event has been added to support triggering a running process instance with an incoming event, with correlation and tenant detection support.
- ➕ Added an Event Registry send event task to support sending events from a process instance and optionally listening for a response event using the triggerable task support.
- 👍 The process instance migration support has been enhanced with supporting batch migration. Migrating a process definition with all its running instances to a new process definition is now possible with one batch, where each instance migration will be a batch part of a parent batch.
- 👌 Support has been added for Kubernetes and HELM charts in specific. For more details see the Github documentation about this https://github.com/flowable/flowable-engine/tree/master/k8s
- 🔧 With historic information growing bigger over time, a way to cleaning this historic information was necessary. For this purpose a history cleaning job was added that can be configured to clean historic information older than a configured time period.
- 👷 To support the history clean job, delete methods have been added to the history query interfaces to also allow to delete historic data with other criteria than just time period based parameters.
- 👍 The mail task has been enhanced with support for sending content items as attachments.
CMMN
- ➕ Added support on a Case definition root level to listen for incoming events to start a new case instance.
- 👍 An Event Registry event listener has been added to support triggering a running case instance with an incoming event, with correlation and tenant detection support.
- ➕ Added an Event Registry send event task to support sending events from a case instance.
- ➕ Added support to inject a Stage or a specific Task in a Stage instance of a running case instance. In this way a CMMN model can be enriched with new Stage or Task logic for a specific case instance.
- 👍 Java Collection support has been added to repetition rules for plan items. This is similar to the Java Collection support for BPMN multi-instance constructs. A Java Collection variable or an expression can be used to define a repetition rule.
- 👍 Enriched the support for evaluating if a Stage can be completed. On a plan item a parent completion rule can be defined with a type that matches the desired evaluation logic.
- 📚 The support for expressions in a case instance has been extended. It's now possible to get a count value for all active plan item instances of a specific definition for example with the following expression: ${planItemInstances.definitionId('a').active().count()}. The CMMN documentation has been updated with all options possible.
- 👍 A mail task has been added to the CMMN engine (similar as the one in the BPMN engine) with support for sending content items as attachments.
EVENT REGISTRY
- 🚀 A new engine was added with the regular deployment and deployment resources support to follow the pattern of the other engines.
- 👌 Support for Event definitions which define the event payload, the channel definition to use, and the optional correlation parameters of an incoming or outgoing event. The BPMN start event, boundary event or send task or the CMMN Case element or event listener are linked to an Event definition based on a logical key, like it's also the case for, for example, BPMN call activities and CMMN case tasks.
- 👌 Support for Channel definitions which define the source or target destination, with a specific adapter type (JMS, Kafka or RabbitMQ by default). Also an event key detection and an optional tenant id detection configuration can be provided. An Event definition links to a Channel definition based on the Channel logical key.
- 👍 When using the Event Registry Spring module, there are 3 out-of-the-box adapters supported, JMS, Kafka and RabbitMQ.
DMN
- ➕ Added support for DMN 1.2, which is the revision of the DMN 1.1 specification. The Collect hit policy logic was changed to not only consider unique outcome values but every outcome value for which the rule was hit. This was changed in the DMN 1.2 specification version.
➕ ADDITIONAL
- 🚀 In this release an upgrade to Spring Boot 2.2.2 and Spring 5.2.2 was done. This is the last release where we have official support for Spring Boot 1.5.x and Spring 4.x. Starting from the next release this will not be officially supported anymore.