As a open platform, we strive to be open about progress and contributions we make to the government and overall open source development communities around the world.
We continually update our progress to share new features, exciting news, and contributions that we development for digital public services.
September 2018
Camunda BPM's REST API does not have any authentication by default. You can enable Basic Auth with a built in plugin, but there is no JWT token support. JWT is commonly used throughout microservices, and therefore we wanted to ensure that the community can use JWT tokens with Camunda's API. We have released the Camunda JWT Authentication Provider, which will allow instant injection of JWT authentication into the API and allow easy customization of the exact JWT Validation as per your in-house JWT design.
Github RepoAugust 2018
We are excited to release the first iteration of the Camunda Deployment Maven plugin! This plugin allows anyone using Maven to easily deploy to the Camunda Rest API; all files (BPMN, DMN, CMMN, JS, etc), that are part of their deployment resources; all with a simple maven command. This drastically decreases complexities in third-party systems deploying to Camunda through the rest api (such as Jenkins). Check it out, we are sure it will change your deployment strategy for the better!!!
Check out the Github Repo to get startedAugust 2018
For a while there has been Unit Testing coverage using a community extension of Camunda BPM. But this extension required using a customized engine, and we found it typically a barrier when trying to get usage reports. There was not a lot of easy to integrate customization, and if you wanted extra data it required a high level of specialized knowledge. So DigitalState developed a Groovy based Coverage generator that can be integrated into any Unit test system. At any point you can take "Coverage Snapshots" which will then export to .html files with the full coverage data pulled from the Camunda DB during execution. These html files can be added into large unit test reports or used as standalone! We are very excited about the usage of this, and how it will enhance business analysis with unit testing visuals that can be used throughout the development, deployment, and continual improvement of business processes in government!
Github RepoAugust 2018
Having testable BPMN's is important: but it is typically a steep learning curve for business analysts to learn how to write unit tests for BPMN! No longer! We have now released our Unit Testing Helpers for Camunda BPM Unit Testing. These helpers provide a Groovy syntax to easily setup and execute BPMN unit tests without the typical boilerplate knowledge and extra lines of code. Things are clear and easy to use! And there is no too much magic going on. Tests are designed to be used with Spock Framework, so they are clear and easy to read by devs and business staff
Check out the Github Repo to get startedAugust 2018
Camunda defaults their logging to the Java logging format. This is not great for importing logs into third-party logging processors such as Elastic Search and Graylog. DigitalState has created the Camunda JSON Logging pattern, allowing JSON Logs to be easily enabled on Camunda Shared Engine deployments using Logback. This community contribution provides a easy to use Docker image that extends from the official Camunda docker images, and creates new layers on the docker image to configure all required dependencies and files for JSON logging. It even supports Pretty-Print! Get started in a matter of seconds!
Github Repo Camunda Forum PostJuly/August 2018
We are very excited to introduce oAuth support into the Authentication microservice.
This oAuth support is database driven giving tenant administrators the power to enable
and disable oAuth integrations during regular operations without downtime.
Each tenant can operate multiple oauth providers and each provider can have multiple instances.
oAuth is seamlessly integrated into the JWT token generation, and provides multiple opportunities
for customization of the registration and login processes.
In a subsequent release we will also be looking to introduce BPMN integration into
registration process, allowing the power of BPMN process definition into how new Identities are registered.
Tenants also introduces the power of a single login for multiple Tenants!
Users can now login through a single oAuth provider (social media or any other provider), and access their various identities that are within the various tenants.
This allows multi-government login under a single login while still maintaining full data privacy and control by each government. (Think multiple cities (tenants) all part of the same "providers" deployment).
Data is always isolated by tenant and is never exposed. Data remains private and secure, maintaining compliance with private laws!
July 2018
Tenants are a constant request for large governments and with private sector customers
looking to build a platform for multi-governments to use.
The Tenants system introduces the core concepts to tenants across all microservices,
adds a top-level security layer for tenants, and we also introduced the Tenants Microserice,
which provides a complete Tenants management solution.
Tenants are part of the core community edition, and the Tenants microservice for easy
tenant management across all microservices is part of the enterprise version.
Tenants system also provides a powerful "Universe" concept allowing Tenants to be owners of other tenants.
This concept allows The creation of layered permissions management where a Government or "cloud-like-provider"
can be a tenant of a larger system, but manage multiple tenants within the provider's tenant.
June 2018
Adding robust security and permissions backed by DigitalState's "Core" microservices module, and providing a secure front to the Formio Validation Server. Adding also the ability to generate Tenants that align with the DigitalState Tenants System. Previously, the open source version of Formio was managed as a standalone docker based microservice that used the out of the box Formio Web UI and Node server. Additional complexeties came up when a more robust mapping between the DigitalState architecture and client requirements, and the Open Source capabilities of Formio. We decided it was best to front the Node server with a API-Platform.com based microservice (to which the rest of DigitalState's microservices are based on), and provide all of the amazing features that the other microservices already provide!
Forms MicroserviceJune 2018
Timers are complex in BPMN: You have Due Dates, Recurring Dates, Cron Cycles, and Durations. When we build and execute a BPMN for a government business process, we want to ensure that timers are executing correctly. In previous work, this always required building a developing executable business flows that were new fully unit tested. This was heavy and cumbersome for most, so DigitalState developed a Spock Framework Unit Testing pattern for ensuring that Timers in the BPMN models would properly execute without the need to test the entire model!
Check it out!May 2018
Camunda BPM offers a powerful BPM engine, but form validations are something of a weak spot. When you leverage the API, the engine provides not security around variable modification. So you need a way to control access to which variables can be modified and by who. The Camunda security system does not support variable level security. So we wanted to add the ability to dynamically and easily add variable security. Turns out that this is really asking for "Scripting": So we added the ability to define a Javascript script that would execute whenever a Form was being submitted. This javascript would validate the data changes trying to be made through the form, and either allow or deny the changes. We then needed to add support for returning proper REST API errors when a Form Validation error occurred, so we created a modification to the Camunda Rest API and provided a pull request.
Our Pull Request to Camunda BPMMay 2018
Another great release! Camunda provides a light weight, robust, BPMN engine; but it does not provide, explicitly many of the robust data management features that we typically expect: such as Data integrity signing: That is, the ability to sign with a RSA certificate a chunk of data to ensure it's integrity. But Java does provide this. So building on previous work from Data Encryption of Camunda process variables using RSA, we now add the ability to Crypto sign Camunda Process Variables using a RSA certificate. We integrated this ability right into reusable javascript scripts, that can be leveraged in any script execution in Camunda BPM.
Signed Objects ScriptsMay 2018
Vertx.io provides a amazing ability to create Polyglot applications and use a variety of
scripting languages (such as Javascript).
When we connect Vertx into a Camunda SpringBoot application wrapper,
we end up with a extremely powerful pattern to build and extend Rest APIs and new
functions that the Camunda BPM engine can take advanage of.
We can now build and deploy new Camunda APIs in a matter of minutes, scale
these across a cluster using Vert.io and leverage the power of SpringBoot!
We could not be more excited!
As a followup, we also created a Camunda Plugin that deploys Vertx directly
inside of a existing Camunda application (such as a Tomcat instance).
This creates a extremely powerful framework for building new features outside
of the Camunda engine, but still leverage the camunda Java API directly inside of
a Vertx application.
April 2018
A valuable release for Data Security! Data encryption is a constant request in the Camunda community. People want to store sensitive data during a BPMN process execution, but they do not have the easy to use functions to encrypt and decrypt data. DigitalState, having the same issues, has solved this issue with easy to use and integrate, scripts that will leverage code Java encryption APIs to provide RSA Public-private Key encryption. Check it out, it is a complete game changer for data security in business processes on the Camunda BPM platform!
Camunda Process Variable RSA Encryption Github RepoMarch 2018
Camunda has the ability to create "Incidents", which are generated alerts and logs about a business or technical error that occured. But Camunda does not provide a way to manage these alerts as part of a dynamic implementation. This means that when you want to build a incident handler, you need to build a Java based plugin that issues the specific class. In our view this is a Big Problem! It means that a Business Analyst cannot write a incident handler / They cannot "handle" the event that they generate in their business process. So we set out to solve this problem... We created a javascript based incident handler: This handler allows anyone creating a BPMN to assign one or more "handlers" in their BPMN properties, and those handlers will point to javascript files. As a result we can execute incident handlers as a "javascript" function, and the analyst can have full control of the input and output/resolution of those incidents! Powerful stuff!!
February 2018
Creating users in Camunda BPM usually follows 3 possible paths: manual user creation, LDAP users, or users created by a Java process application. These scenarios are controversial when using camunda as a microservice. So we created a plugin that lets you define a base Administrative user when the engine first starts up. This lets you define the user in the Camunda configs, and then use your regular third-party REST API connections to Camunda to generate other users as you see fit!
January 2018
The Reporting microservice has been updated with the latest Kiabana and Camunda Json History provider enhancements! This gives our users, amazing reporting capabilities, and the ability to have realtime insights into every aspect of BPM workflow and other microservices.
With the new Elastic Search and Kiabana reporting for Camunda, you can leverage Machine Learning and automated reporting!
January 2018
Camunda provides a default History provider (where all history logs are kept), which is a database driver provider. The problem is when you want to run big-data-like queries using tools like ElasticSearch and Kiabana, you run into issues: The History is not in a JSON format. We created a JSON history provider that exports all data in realtime from Camunda into a JSON file format, which can then be consumed by File Beats, processed by Logstash, and imported into Elastic Search for reporting with Kiabana.
January 2018
External task workers are great! but they are a pain to build for use with Camunda BPM. Generally we want to quickly scale up and down a task worker with little overhead.... Vertx to the rescue! We leverage Vertx's javascript execution capabilities to provide us with a JVM based vertx deployment using Javascript. This means we build Javascript based applications that are actually running Vertx on the JVM. We can build scalable, cluster-based, high-availability applications with extremely minimal amounts of code!
January 2018
We need ways to storage variables in multi-instance storage: also known as: when we are executing business processes in parallel that are saving data for the "same thing", then we need a storage location that can accept multiple writes in parallel and reconcile these afterwards: Redis Lists to the rescue!
December 2017
Unit Testing and just testing your executable business processes, in general,
sucks.... So lets make it better... a lot better; Introducing Camunda Unit
Testing using Spock Framework. Spock Framework gives us the best of two worlds:
Code drive unit testing, and BDD Unit testing with business friendly
language and reports!
We get all of the Java unit testing, but we get to write in friendly Groovy,
and we can quickly teach a even semi-technical business analyst to build and
manage unit tests within a few days.
Life is getting easier, and Unit Testing should be something that use as a
default build product for all BPMN, DMN, and CMMN: But in order to do this,
we need to ensure it is sooooooo easy to build the typical tests, and managers
and developers do not even think twice.
Spock Framework + Camunda + DigitalState Camunda Unit Testing Patterns ==
something very special for all the Government departments!!
as a extra special feature, with Spock Framework we can easily
implement Javascript testing as well. This means that all of the
scripts that we write for camunda, are not fully unit tested and
'flawless' from careless bugs ;)
December 2017
Easily send Twilio SMS messages based on BPMN processes. All Script based, and easily modifieable for whatever your use case!
At times you want to use a BPMN process as a reusable function. But when using this process as a function, you want to start accessing that function as a Rest API and not just within another BPMN. With DigitalState's Services Microservice, that is used for Government Services, we also implement a Function as a Service beta. This lets someone build a Function that returns specific Rest API responses controlled by the Services Microservice. Some really amazing use cases! When Zeebe.io arrives from Camunda, this can go to the next level!
