Tuesday, April 15, 2014

Use camunda bom for maven Dependency Management

Sometimes you need to include multiple camunda BPM maven dependencies in your project. The apache maven best practice  is to use a bom ("Bill of Materials") which ensures that you get the matching versions for multiple dependencies. For camunda bpm we prepared the camunda-bom to make sure you get the right versions for all camunda dependencies and our transitive dependencies.

First, import the camunda-bom in the dependencyManagement section of your maven pom:

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.camunda.bpm</groupId>
        <artifactId>camunda-bom</artifactId>
        <type>pom</type>
        <scope>import</scope>
        <version>7.1.0-Final</version>
      </dependency>
    </dependencies>
  </dependencyManagement>

Now you can reference multiple camunda dependencies without adding their <version> information:

  <dependencies>
  
    <dependency>
      <groupId>org.camunda.bpm</groupId>
      <artifactId>camunda-engine</artifactId>
    </dependency>

    <dependency>
      <groupId>org.camunda.bpm</groupId>
      <artifactId>camunda-engine-spring</artifactId>
    </dependency>
    
    ...

What's more: we also give you the versions for the the required dependencies of camunda engine. This way you will always get the version of mybatis, joda-time, java-uuid-generator that the current version of camunda-bpm was built and tested with:

<dependencies>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
    </dependency>

    <dependency>
      <groupId>joda-time</groupId>
      <artifactId>joda-time</artifactId>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.uuid</groupId>
      <artifactId>java-uuid-generator</artifactId>
    </dependency>
    
    ...

Note that most of our maven artifacts are pushed to maven central.

Saturday, April 5, 2014

Get started with camunda BPM and Java EE

Roman and Sebastian have written a brand new getting started guide for camunda and Java EE.


The guide is a detailed step-by-step tutorial about how to setup your Java EE 6 application for camunda BPM and BPMN. It has examples about how to use JSF for implementing Task Forms, CDI and EJB as a programming model for the business logic and JPA for custom persistence.

The source code of the tutorial can be found on github. Since the guide is a step-by-step tutorial, you can checkout the source code for each step as a tag in git.

I hope you like the tutorial, please give us feedback in the forums and via @camundaBPM.

Read the guide on how to get started with camunda BPM and Java EE.

Friday, April 4, 2014

camunda Modeler 2.5.0 released: Extension elements, properties panel and bug fixes


The camunda BPM team is pleased to announce the release of camunda Modeler 2.5.0. This release is dedicated to align the latest improvements of camunda BPM 7.1 with the modelers properties panel. Furthermore we implemented a new properties tab for extension elements and of course we fixed bugs.

Find a complete list of issues solved in this release in JIRA.

This release covers Eclipse Kepler and Juno/Indigo as well as the camunda ModelerStandalone.

Monday, March 31, 2014

Finally! camunda BPM 7.1.0-Final is released

Today we release 7.1.0-Final, the new minor version of camunda BPM. Compared to the 7.0.0.Final release, the new version includes many new features and improvements:
  1. Improved process engine with Job Definitions, better BPMN coverage and improved performance,
  2. All-new BPMN Model API for convenient BPMN model access,
  3. New features in the cockpit monitoring web application,
  4. Improved Tasklist and Task Forms, including support for HTML5 and Generated Task Forms.
  5. Support for Oracle WebLogic Server 12c and JBoss Application Server 7.2 and JBoss EAP 6.1 / 6.2
This blog post contains a more detailed feature overview below. The release is now available on camunda.org for download:


All in all, 320 issues were closed. See the complete release notes in Jira.

Tuesday, March 18, 2014

New: camunda BPM network

On March 14 we merged the online community BPM-Netzwerk.de with more than 10,000 members into the new camunda BPM network.

I personally created the first version of this community in 2004, and together with Robert Emsbach grew the community in the German speaking area. I learned a lot about community building during that time, especially in the BPM world.

Now camunda takes over and will bring our network to the next level: Firstly, we want to grow our community outside the German speaking area as well, and secondly we want to explore new possibilities for discussing BPM online, that should go beyond the typical instruments we already know from general virtual communities. That's why we created the BPMN forum for discussing BPMN diarams online.

This video provides a short introduction: http://vimeo.com/89381906

It would be great if people should like this new way of discussing BPM(N) online (right now the first reactions look pretty promising), and I would like to express my gratitude to Robert for the great time we had with BPM-Netzwerk.de. He is a BPM enthusiast just like me, but way more important, he is a very good friend.

Monday, March 17, 2014

Fluent API for Message Correlation

camunda BPM 7.1.0-alpha4 features a new fluent API for message correlation.

BPMN 2.0 defines events and tasks catching messages. The following is a fragment of a process waiting for an order to be cancelled:
Intermediate Message Catch Event
In BPMN 2.0 XML you have to provide a name for the message you want to catch:

<bpmn2:definitions ...>
  ...
  <bpmn2:message id="Message_1" name="orderCancelled"/>
  ...
  <bpmn2:process id="Process_1" isExecutable="false">
    ...
    <bpmn2:intermediateCatchEvent id="IntermediateCatchEvent_2" name="Order &#xA;Cancelled">      
      <bpmn2:messageEventDefinition messageRef="Message_1"/>

    </bpmn2:intermediateCatchEvent>
    
  </bpmn2:process>

New Fluent API

camunda Engine now featues a fluent DSL for correlating this message to the process engine:

  runtimeService.createMessageCorrelation("orderCancelled")
      .processInstanceBusinessKey("someOrderId")
      .setVariable("CANCEL_REASON", "someReason")
      .setVariable("CANCEL_TIMESTAMP", new Date())
      .correlate();

The fluent DSL makes it easy to define a complex correlation set based on different restrictions. The above example correlates the message on the business key. On top of that, correlation based on process variables and process instance id is supported:

  runtimeService.createMessageCorrelation("orderCancelled")
      .processInstanceVariableEquals("orderId", "someOrderId")
      .processInstanceVariableEquals("customerId", "someCustomerId")
      .correlate();

  runtimeService.createMessageCorrelation("orderCancelled")
      .processInstanceId("someProcessInstanceId")
      .correlate();

The API also makes it easy to provide the message payload as a single or multiple variables through setVariable(varName, value).

More Efficient than Query + Trigger

We recommend using the fluent DSL or the RuntimeService.correlateMessage(...) methods introduced in 7.0 over the Query + Trigger pattern. Using the Query + Trigger pattern you first query for an execution having a message event subscription and then trigger that execution:

Not as efficient:

  // Query
  Execution e = runtimeService.createExecutionQuery()
    .processInstanceBusinessKey("someOrderId")
    .messageEventSubscriptionName("orderCancelled")
    .singleResult();

  Map<String, Object> variables = new HashMap<String, Object>();
  variables.put("CANCEL_REASON", "someReason");
  variables.put("CANCEL_TIMESTAMP", new Date());

  // Trigger
  runtimeService.messageEventReceived("orderCancelled", e.getId(), variables);

The Query + Trigger pattern has two disadvantages:
  1. More lines of code :)
  2. Two process engine commands instead of a single one. This makes it less efficient in terms of performance.

Thursday, March 13, 2014

camunda Grails Plugin by Martin Schimak

Martin Schimak (who is a community member and contributor) has written a Grails plugin which allows users to get started quickly with camunda on grails.



The plugin was accepted by the Grails community and was published in their plugin repository:
http://grails.org/plugin/camunda

The code is pushed to github: https://github.com/plexiti/camunda-grails-plugin

Amazing Stuff!!