Drools & jBPM

Backward Chaining and Reactive Transitive Closures with Drools

noreply@blogger.com (Mark Proctor) — Fri, 24 May 2013 07:40:00 +0000

I've made a small tutorial on Backward Chaining and Reactive Transitive Closures with Drools.
Don't forget to turn on Youtube HD settings:
https://www.youtube.com/watch?v=fCjIRVSRFvA

Drools and Guvnor Beta3 Video

noreply@blogger.com (Mark Proctor) — Fri, 24 May 2013 05:46:00 +0000

I've made a small video to show the UI improvements for Drools and Guvnor. It's recorded in 1024x768, so it's slightly more cramped, people typically have their UI's open larger than that these days. Don't forget to turn on Youtube HD settings:
https://www.youtube.com/watch?v=ckAznbOOV-4

Creating your own Drools and jBPM Persistence with Infinispan

noreply@blogger.com (Marian Buenosayres) — Tue, 14 May 2013 19:35:00 +0000

Original post here by me:

Hello and welcome to a post in which I intend to show you how to create your own implementation of drools and jBPM persistence. I’ve worked on an infinispan based persistence scheme for drools objects and I learnt a lot in the process. It’s my intention to give you a few pointers if you wish to do something of the sort.

Why?

If you’re reading this, you probably already have a “why” to redefine the persistence scheme that drools uses, but it’s good to go over some good reasons to do something like this. The most important thing is that you might consider the JPA persistence scheme designed for drools doesn’t meet your needs for one or more reasons. Some of the most common I’ve found are these:

The given model is not enough for my design: Current objects created to persist the drools components (sessions, process instances, work items and so on) currently are as small as possible to allow the best performance on the database, and most of the operational data is stored in byte arrays mapped to blob objects. This scheme is enough for the drools and jBPM runtime to function, but it might not be enough for your domain. You might want to keep the runtime information in a scheme that is easier to query from outside tools, and to do that you would need to enrich the data model, and even create one of your own.

The persistence I’m using is not compatible with JPA: There are a lot of persistence implementations out there that no longer use databases as we once knew (distributed caches, key value storages, NoSQL databases) and the model usually needs extra mappings and special treatment when persisting in such storages. To do so, sometimes JPA is not our cup of tea

I need to load special entities from different sources every time a drools component is loaded: When we have complex objects and/or external databases, sometimes we want new models to relate in a special way to the objects we have. Maybe we want to make sure our sessions are binded to our model in a special way because it makes sense to our business model. To do so we would have to alter the model

How?

In order to make our own persistence scheme for our sessions, we need to understand clearly how the JPA scheme is built, to use it as a template to build our own. This class diagram shows how the JPA persistence scheme for the knowledge session is implemented:

Looks complicated, right? Don’t worry. We’ll go step by step to understand how it works.

First of all, you can see that we have two implementations of the StatefulKnowledgeSession (or KieSession, if you’re using Drools 6). The one that does all the “drools magic” is StatefulKnoweldgeSessionImpl, and the one we will be using is CommandBasedStatefulKnowledgeSession. It has nothing to do with persistence, but it helps a lot with it by surrounding every method call with a command object and deriving its execution to a command service. So, for example, if you call the fireAllRules method to this type of session, it will create a FireAllRulesCommand object and give it to another class to execute.

This command based implementation allows us to do exactly the thing we need to implement persistence on a drools environment: It lets us implement actions before and after every method call done to the session. That’s where the SingleSessionCommandService class comes in handy: This command service contains a StatefulKnowledgeSessionImpl and a PersistenceContextManager. Every time a command has to be executed, this class creates or loads a SessionInfo object and tells the persistence context to save it with all the state of the StatefulKnowledgeSessionImpl.

That’s the most complicated part: the one that implements the session persistence. Persistence of pretty much everything else is done easily through a set of given interfaces that provide methods to implement how to load everything else related to a session (process instances, work items and signals). As long as you create a proper manager and its factory, you can delegate on them to store anything to anywhere (or do anything you want, for that matter).

So, after seeing all the components, it’s a good time to start thinking of how to create our own implementation. For this example, we’ve created an Infinispan based persistence scheme and we will show you all the steps we took to do it.

Step 1: (re)define the model

Most of the time when we want to persist drools objects in our way, we might want to do it with a gist of your own. Even if we don’t wish to change the model, we might need to add special annotations to the model to work with your storage framework. Another reason might be that you want to store all facts in a special way to cross-query them with some other legacy system. You can literally do this redefinition any way you want, as long as you understand that whatever model you create, the persistence scheme will serialize and deserialize it every time you call a method on the knowledge session, so always try to keep it simple.

Here’s the model we created for this case:

Nothing too fancy, just a flattened model for all things drools related. We weren’t too imaginative with this model, because we just wanted to show you that you can change it if you want to.

One thing to notice in this model is that we are still saving all the internal data of these objects pretty much the same way as it is stored for the JPA persistence. The only difference is that JPA stores it in a Blob, and we store it in a Base64 encrypted string. If you wish to change the way that byte array is generated and read, you have to create your own implementations of these interfaces:

org.kie.api.marshalling.Marshaller for knowledge sessions

org.jbpm.marshalling.impl.ProcessInstanceMarshaller for process instances

But providing an example of that would take way too much time and perhaps even a whole book to explain, so we’ll skip it :)

Step 2: Implementing the PersistenceContext

For some cases, redefining the PersistenceContext and the PersistenceContextManager would be enough to implement all your persistence requirements. The PersistenceContext is an object in charge of persisting work items and session objects by implementing methods to persist them, query them by ID and removing them from a particular storage implementation. The PersistenceContextManager is in charge of creating the PersistenceContext, either once for all the application or on a per-command basis. The comand service will use it to persist the session and its objects when needed.

In our case we implemented a PersistenceContext and a PersistenceContextManager using an Infinispan cache as storage. The different PersistenceContextManager instances will have access to all configuration objects through the Environment variable. We’ve used the already defined keys in Environment to store our Infinispan related objects:

EnvironmentName.ENTITY_MANAGER_FACTORY is used to store an Infinispan based CacheManager

EnvironmentName.APP_SCOPED_ENTITY_MANAGER and EnvironmentName.CMD_SCOPED_ENTITY_MANAGER will point to an Infinispan Cache object.

You can see that code here:

At this point we have some very important steps to redefining our drools persistence. Now we need to know how to configure our knowledge sessions to work with this components.

Step 3: Creating managers for our work items, process instances and signals

Now that we have our persistence contexts, we need to teach the session how to use them properly. The knowledge session has a few managers that can be configured that allow you to modify or alter the default behaviour. These managers are:

org.kie.api.runtime.process.WorkItemManager: It manages when a work item is executed, connects it with the proper handler, and notifies the process instance when the work item is completed.

org.jbpm.process.instance.event.SignalManager: It manages when a signal is sent to or from a process. Since process instances might be passivated, it needs to

org.jbpm.process.instance.ProcessInstanceManager: It manages the actions to be taken when a process instance is created, started, modified or completed.

JPA implementation of these interfaces already work with a persistence context manager, so most of the times you won’t need to extend them. However, with Infinispan, we have to make sure the process instance is persisted more often than with JPA, so we had to implement them differently.

Once you have these instances, you will need to create a factory for each type of manager.The interface names are the same, except with the suffix “Factory”. Each receives a knowledge session as parameter, from which you can get the Environment object and all other configurations.

Step 4: Configuring the knowledge session

Now that we have our different managers created, we will need to tell our knowledge sessions to use them. To do so you need to create a CommandBasedStatefulKnowledgeSession instance with a SingleSessionCommandService instance. The SingleSessionCommandService, as its name describes, is a class to execute commands against one session at a time. SingleSessionCommandService’s constructor receives all parameters needed to create a proper session and execute commands against it in a way that it becomes persistent. Those parameters are:

KieBase: the knowledge base with the knowledge definitions for our session runtime.

KieSessionConfiguration: Where we configure the manager factories to create and dispose of work items, process instances and signals.

Environment: A bag of variables for any other purpose, where we will configure our persistence context mananager objects.

sessionId (optional): If present, this parameter looks for an already existing session in the storage. Otherwise, it creates a new one.

Also, in our example, we’re using Infinispan, which is not a reference based storage, but a value based storage. This means that once you say to infinispan to store a value, it will store a copy of it and not the actual object. Some things in drools persistence are managed to be stored through reference based storages, meaning you can tell the framework to persist an object, change its attributes, and see those changes stored in the database after committing the transaction. With infinispan, this wouldn’t happen, so you have to implement an update of the cache values after the command execution is finished. Luckily for us, the SingleSessionCommandService allows us to do this by implementing an Interceptor.

Interceptors are basically your own command service to wrap the default one. You can tell each command to add more behaviour before or after each execution. Here’s a couple of diagrams to explain how it works:

As you can see, the SingleSessionCommandService allows for a command service instance to actually invoke the command’s execute method. And thanks to the interceptor extension of the command service, we can add as many as we want in chain, allowing us to have something like the next sequence diagram executing every time a command needs execution:

In our case, we created a couple of these interceptors and added them to the SingleSessionCommandService. One makes sure any changes done to a session object are stored after finishing the command. The other one allows us to do the same with process instance objects.

Overall, this is how we need to create our knowledge sessions at this point to actually use infinispan as a persistence scheme:

Complicated, right? Don’t worry. There’s yet another couple of classes to make it easier to configure.

Step 4: Creating our own initiation service

Yes, we could write that ton of code every time we want to create our own customized persistent knowledge sessions. It’s a free world (for the most part). But you can also wrap this implementation in a single class with two exposed methods:

One to create a new session

One to load a previously existing session

And creates all the configuration internally, merging it whenever you wish to change one or more things. Drools provides an interface to serve as a contract for this called org.kie.api.persistence.jpa.KieStoreServices

We created our own implementation of this interface and also a static class to access it, called InfinispanKnowledgeService. This allows us to be able to create the session like this:

Conclusion

Drools persistence can seem complicated to understand and to get working, let alone to implement it in your own way. However, I hope this shows a bit of demystification to those who need to implement drools persistence in a special way, or were even wondering if it is possible to do so in any other way than JPA.

Also, if you wish to see the modifications done to make it work, see these three pull requests:

https://github.com/droolsjbpm/droolsjbpm-build-bootstrap/pull/38

https://github.com/droolsjbpm/drools/pull/198

https://github.com/droolsjbpm/jbpm/pull/166

A feature request to add this features to Drools is specified in this JIRA ticket. Feel free to upvote it if you wish to have it as part of the core drools project!

London JBUG May Event - What's new in Drools 6.0 (22nd May 2013)

noreply@blogger.com (Mark Proctor) — Tue, 07 May 2013 08:35:00 +0000

http://www.c2b2.co.uk/london_jbug_may_2013

London JBUG May Event - What's new in Drools 6.0

WHEN	WHERE	HOW TO REGISTER?
Wednesday 22nd of May 2013 6pm-8:30pm	Skills Matter eXchange 116-120 Goswell Road London, EC1V 7DP	Fill in the form at the bottom of the page!

If you are interested in attending the future JBUG events please join JBUG on Meetup

Presentation

Drools 6.0 introduces new approaches for authoring, building, deploying and utilising rules. Using convention and configuration, over programmatic apis, in an effort to simplify the experience for end users.

This talk, presented by Mark Proctor - Platform Architect at Red Hat - will take users through the new web based IDE (built with UberFire) for authoring and deploying rules, and then utilising them on the client side. It will also introduce the other new 6.0 features, including our new lazy rule engine algorithm. Ideally attendees will have a basic understanding of Drools and rule engines.

Speaker

Mark Proctor received his B.Eng in Engineer Science and Technology and then his M.Sc. in Business and Information Systems; both from Brunel University, West London. His M.Sc. thesis was in the field of Genetic Algorithms; which is where he discovered his interest for anything AI related.

For the last 10 years Mark's focus has been on developing knowledge engineering systems in java, while working for Red Hat as Platform Architect. Mark is the co-founder of the Drools project, the leading Java expert system tool, and as Platform Architect he is responsible for all technologies related to rules, processes, events, ontologies and intelligent agents at Red Hat.

Agenda

18:00 - 18:15 - Coffee, Welcome and Networking
18:15 - 19:30 - 'What's new in Drools 6.0' by Mark Proctor
19:30 - 19:50 - Lightning Talks / Problem Solving Sessions
'Hands off my data! How to use Off-Heap Memory from Java and keep the latencies down' lightning talk will be presented by Jaromir Hamala
19:50 - 20:30 - Beer, Pizza and Networking

‘Problem Solving’ Sessions

Following your suggestions, we’re introducing the new Problem Solving panel sessions which give you an opportunity to discuss various JBoss-related problems you may want to share and discuss with the rest of the JBUG members. If you want to ask others for help and advice, discuss the issues, listen to suggestions and find the solutions – let us know! Email your topic to jbug@c2b2.co.uk and we will be more than happy to add your session to the agenda.

Lightning Talks

We are also opening up the floor to anyone using JBoss who has a tale to share. We are looking for a number of lightning talks 5 - 10 minutes in length where you can share your experiences, problems or wonderful solutions with the rest of the community. This is a huge opportunity to develop new or hone existing speaking skills!

If you are interested, please send the title of your talk to jbug@c2b2.co.uk .

Drools and jBPM talks at JUDCon:2013 United States

noreply@blogger.com (Ray Ploski) — Mon, 06 May 2013 17:20:00 +0000

In Boston in June? Meet some of the leaders of the Drools and jBPM teams! Mark Proctor and Edson Tirelli will be be speaking this June at JBoss User and Developer Conference. Take advantage of meeting Mark and Edson there. It is a great opportunity to share your ideas and implementations.

Admission tickets get you into three separate events: Red Hat Developer Exchange, JBoss User Developer Conference (JUDCon) and CamelOne. The events will be held in Boston Sunday June 9th - Tuesday June 11th.

JUDCon:

The activities start Sunday evening June 9th with the JUDCon, CamelOne and Red Hat Exchange reception. Then Monday and Tuesday, there will be 3 tracks of sessions, and 2 workshop tracks as well. The evening will also include a JBoss Core Developer panel, a live recording of the JBoss Community Asylum, and yes, beer.

The JBoss Users and Developers Conferences are developer gatherings held around the Globe to give JBoss users the chance to talk to and collaborate with Java contributors and core developers. The core JBoss developers, along with the open source community, create and support the projects that drive innovation and help lead development in standards bodies like the Java Community Process, the Apache Software Foundation, OASIS, W3C and other open standards organizations. Many of these projects become the upstream for Red Hat JBoss products.

3 tracks and 33 sessions will cover topics including:

Java and Java EE App Development
Mobile Development
Drools, jBPM, Fuse, ActiveMQ, Infinispan
and many more

6 workshops providing hands-on labs covering:

Ceylon taught by Gavin King and Stephane Epardaud
Infinispan and JBoss Data Grid cross-datacenter replication
CDI, Forge and Errai
and many more.

JUDCon:2013 Boston Agenda

http://www.jboss.org/events/JUDCon/2013/unitedstates/agenda

CamelOne:

CamelOne is designed specifically for professionals using open source integration and messaging solutions in the enterprise and will feature a combination of keynote presentations, educational sessions and networking events that will enable attendees to meet, learn and share ideas with open source integration experts.

Founders, committers and users of Apache Camel, ServiceMix, ActiveMQ and CXF enjoyed a great Meet and Greet in the Exhibit Hall from 6:30 to 8:30. Stop by and mingle with your community over hors d’oeuvres and drinks!

CamelOne Agenda

http://www.camelone.com/apache-camel-conference-2013/camelone_agenda_2013/

Red Hat Developer Exchange:

Red Hat Connect Developer Exchange is heading back to Boston. You won't want to miss this one-day event where you can learn more about Red Hat developer tools and technologies. From gcc to Java to scripting languages, from traditional models to devops--You'll get the chance to connect with fellow developers, share real-world challenges, and solve mutual problems through collaboration.

5 tracks and 25 sessions will cover important topics, including:

• Programming on OpenShift Online PaaS

• OpenShift Enterprise and Java

• Languages and tools for mission-critical development

• Get more out of Red Hat Enterprise Linux tools

Red Hat Developer Exchange Agenda:

http://www.redhat.com/developerexchange/agenda/

IntelliFest Oct 2013 - San Diego

noreply@blogger.com (Mark Proctor) — Fri, 03 May 2013 11:29:00 +0000

Keynote Speakers:

Dr. Ernest Friedman-Hill (Jess)
Dr. Daniel Miranker (Treat, Leaps, Venus)
Dr. Ellen Voorhees (Information Retrieval, National Institute of Standards and Technology, NIST)

International Conference
on Reasoning Technologies

October 7-11 • Bahia Resort Hotel

San Diego, CA • USA

IntelliFest returns to the charming Bahia Hotel for 2013! Join us for a full program featuring:

Single track technical conference for software and IT developers, programmers, engineers, and architects in the applied AI and rule-based domains.
Welcoming Reception on Sunday, October 6.
Technical Vertical Day on Monday, October 7.
Two days of boot camps on Monday, October 7 and Friday October 11!
Main Conference, Tuesday, October 8 through Thursday, October 10
AM plenary sessions with guest keynotes each day!
Hands-on, mini-camps all during the PM sessions of the main conference!

Topics include but are not limited to:

Reasoning About Big Data AI and Cloud Computing
AI and the Semantic Web
Emerging Standards
Latest News in Rule Engines
… and much more!

Google Summer of Code 2013

noreply@blogger.com (Kris Verlaenen) — Wed, 01 May 2013 22:37:00 +0000

JBoss is participating in the Google Summer of Code 2013 program, which means that students can work on their favourite open-source project during the summer and get ultimate glory and a nice paycheck in return.

Google Summer of Code is a global program that offers students stipends to write code for open source projects. We have worked with the open source community to identify and fund exciting projects for the upcoming summer.

JBoss has created a list of possible ideas you can take a look at, but you can always propose us your own ideas as well !

For Drools & jBPM, we've added a few ideas to the list, but there is a Wiki page with over 10 possible jBPM proposals available here, including:

jBPM on android
Integrating jBPM with your own preferred project(s)
Realtime Collaborative Editor for Drools Decision Tables using GWT and Errai OT/EC
jBPM performance on steroids
Document management system
Mobile client(s) for jBPM
From BPEL to BPMN2
Social BPM using jBPM
Process mining for jBPM
jBPM and Drools for access control
jBPM and Drools for clinical decision support

The deadline for student applications is May 3rd, 19:00 UTC, so if you're interested but didn't submit anything yet, you'll need to be fast!

Try the jBPM Console NG (Beta)! (for developers)

noreply@blogger.com (salaboy) — Mon, 29 Apr 2013 21:22:00 +0000

Hi everyone out there! This is another post about the jBPM Console NG. After 6 months of heavy work I'm happy to be writing this post for the developers community to try it out. On this post I will be explaining how to build the application from the sources. The main idea behind this is to know how to set up your environment and modify the application while your testing it. You will basically learn all you need to know to contribute with the project.

Introduction

The jBPM Console NG aims to provide a Task & Process Management collaborative environment to facilitate the adoption of the BPM Suite in a company. Downloading the sources and compiling the application will allow you to try the application and modify it in the case that you want to extend it or fix bugs. The application is under the Apache License V2 so it can be used and modified according with this license.

Working with the Source Code

The first step in order to get everything running is to get the source code using GIT. This are the things that you need to have installed in your computer in order to proceed:

JDK 6
Maven 3.x
Git
Any IDE (Eclipse, IntelliJ, Netbeans) with the maven plugin installed
JBoss Application Server 7.1.1 (optional)

Once you get all these tools installed we can proceed to get the source code from the github repository:

https://github.com/droolsjbpm/jbpm-console-ng/

In order to get a "Clone" of the repository to work you must from the terminal:

git clone https://github.com/droolsjbpm/jbpm-console-ng.git

Once it's done, you can compile the source code, here you have two alternatives:

1) Compile the project for development purposes with:

mvn clean install

2) Compile the project to generate the distribution wars for JBoss and Tomcat + the documentation

mvn clean install -PfullProfile

Sit back and relax! The first time that you do this step Maven requires to download tons of libraries, so you will need to wait.

Running the application in Hosted Mode

Once the project is compiled, the jbpm-console-ng-showcase can be executed in what GWT calls "Hosted Mode" (also known as Developer Mode)

In order to start up the application in hosted mode you should do the following:

1) The jBPM Console NG Showcase contains the final application distribution code:

cd jbpm-console-ng-showcase/

2) Run in hosted mode using the GWT Maven Plugin

mvn gwt:run

This will start up a Jetty + the GWT Development Mode screen which will allow you to copy the URL where the application is hosted for you to try it:

: GWT Hosted Mode

Copying the URL (http://127.0.0.1:8888/org.jbpm.console.ng.jBPMShowcase/jBPM.html?gwt.codesvr=127.0.0.1:9997) into your browser (For hosted mode you need to have the GWT plugin installed in your browser, don't worry it's automatically installed if you don't have it) will open the application. I strongly recommend to use Firefox for development mode or Chrome (usually slower), because for developing we scope the compilations to work on FF and Chrome (gecko browsers).

Running the application in JBoss AS 7

Now if you want to deploy the application on JBoss, you need to go the the second compilation option (-PfullProfile) which will take some extra time to compile the application for all the browsers and all the languages (English, Spanish, etc.). In order to deploy the application to your jboss as 7 instance you will need to move the war file generated inside the jbpm-console-ng/jbpm-console-ng-distribution-wars/target/jbpm-console-ng-jboss-as7.war into the <jboss-as>/standalone/deployments directory and then rename the war file to jbpm-console-ng.war. The name of the application will be used as the root context for the application.

For the JBoss you also need to do some configurations for the users and roles. Inside the jBPM Console NG you will need to have set up the users that will be available for your installation. Those are handle by JBoss Security Domains. In order to set up the security domains, you need to do the following:

1) Edit the <jboss_as>/configuration/standalone.xml and add a new security domain:

<security-domain name="jbpm-console-ng" cache-type="default">
<authentication>
<login-module code="UsersRoles" flag="required">
<module-option name="usersProperties" value="${jboss.server.config.dir}/users.properties"/>
<module-option name="rolesProperties" value="${jboss.server.config.dir}/roles.properties"/>
</login-module>
</authentication>
</security-domain>

2) add the users.properties and roles.properties files

content of the user.properties file:

maciek=Merck
salaboy=salaboy
katy=katy
john=john

content of the roles.properties file:


maciek=jbpm-console-user,kie-user,analyst,HR,PM,Reviewer
salaboy=jbpm-console-user,user,analyst,PM,IT,Reviewer
katy=jbpm-console-user,HR
john=jbpm-console-user,Accounting

The only requirement for the roles file is to include the jbpm-console-user role for all the users.

Note that this is the simplest way of configuring a security domain, but you can go for more advanced options, like configuring the security domain to use an LDAP server or a Database to authenticate your users and roles. (https://docs.jboss.org/author/display/AS7/Security+subsystem+configuration)

Then you are ready to go, you can start jboss with:

1) Go into the bin directory:

cd <jboss-as>/bin/

2) Start the application server:

./standalone.sh

On Openshift

In order to deploy the application into openshift you need to obviously have an openshift account. Once you set up your account you will need to do almost the same configurations as in the JBoss Application. In the openshift git repository that you clone, you will have a specific dir to apply this configuration:

.openshift/config

There you will find the standalone.xml file and you can place the users.properties and roles.properties files.

So in the standalone.xml file you will need to configure the security domains as we did before and add the users.property and roles.properties files.

Besides this configuration you will need to set up a system property for storing the knowledge repository:

<system-properties>
<property name="org.kie.nio.git.dir" value="~/jbossas-7/tmp/data"/>
</system-properties>

The Application

Now you are ready to use the application, so if you point your browser to the URL provided by the hosted mode or to http://localhost:8080/jbpm-console-ng/ you will be able to access the login form.

As you will see, before entering the application you will need to provide your credentials. Once you are in the application is divided in:

: Cycle

In the Authoring section you will be able to access to the Process Designer to model your business processes. The Process Management section will allow you to list the available Business Processes and Start new instances, and also monitor those instances. The Work Section will enable you to access the Task Lists (Calendar and Grid View) to work on the tasks assigned to you. In order to use the BAM section you will need to deploy the BAM dashboard application but I will describe that in a future post.

Feel free to try it out and write a comment back if you find something wrong.

Contributions

Your feedback means a lot, but if you want to contribute, you can fork the jbpm-console-ng repository in github: https://github.com/droolsjbpm/jbpm-console-ng/

I will appreciate if you can test the Task Lists and Process Management screens and write feedback in this post, so I can iteratively improve what we have. I will be writing another post to describe the screens and also to list a set of small tasks that you can contribute back.

Score DRL: faster and easier in OptaPlanner

noreply@blogger.com (Geoffrey De Smet) — Fri, 05 Apr 2013 09:39:00 +0000

For OptaPlanner (= Drools Planner) 6.0.0.Beta1, I 've replaced the ConstraintOccurrence with the much more elegant ConstraintMatch system. The result is that your score DRL files are:

much faster
easier to read and write
far less error-prone, because they make it a lot harder to cause score corruption

Let's look at the results first, before we look at the code readability improvements.

Faster

"Show me the benchmarks!"

The average calculate count - which is the number of scores OptaPlanner calculates per second - has risen dramatically.

N queens: +39% calc count for 256 queens
Cloud balance: +27% calc count on average
Vehicle routing: +40% calc count on average
Course scheduling: +20% calc count on average
Exam scheduling: +23% calc count on average
Nurse rostering: +7% calc count on average

However, this doesn't necessarily imply a dramatic improvement in result, especially if the old result is already (near) optimal. It means you can get the exact same result in far less time. But - as with all other performance improvements - gives no promise for significantly better results in the same time. It does helps when scaling out.

Cloud balance: +0.58% feasible soft score on average in 5 minutes
Vehicle routing: +0.14% feasible soft score on average in 5 minutes
Course scheduling: +2.28% feasible soft score on average in 7 minutes
Exam scheduling: +0.53% feasible soft score on average in 7 minutes

Several of the 30 Vehicle routing datasets were already solved optimally in 5 minutes, so these drag the average down, despite the high vehicle routing speedup.

All benchmarks use the exact same Drools and OptaPlanner version, so these numbers show only the improvements of the ConstraintMatch change. There are several other improvements in 6.0.

How does the average calculate count scale?

Here are a some charts comparing the old ConstraintOccurrence with new ConstraintMatch. The new ConstraintMatch's current implementation hasn't been fully optimized, so it's sometimes referred to being in "slow" mode (even though it's faster).

CloudBalance:

Vehicle routing:

Course scheduling:

Exam rostering:

Easier

"Show me the code!"

For starters, the accumulateHardScore and accumulateSoftScore rules are removed. Less boilerplate :) Next, each of the score rule's RHS (= then side) is simpler:

Before:
    rule "conflictingLecturesSameCourseInSamePeriod"
        when
            ...
        then
            insertLogical(new IntConstraintOccurrence("conflictingLecturesSameCourseInSamePeriod", ConstraintType.HARD,
                    -1,
                    $leftLecture, $rightLecture));
    end

After:
    rule "conflictingLecturesSameCourseInSamePeriod"
        when
            ...
        then
            scoreHolder.addHardConstraintMatch(kcontext, -1);
    end

Notice that you don't need to repeat the ruleName or the causes (the lectures) no more. OptaPlanner figures out it itself through the kcontext variable. Drools automatically exposes the kcontext variable in the RHS, so you don't need any extra code for it. Also, the limited ConstraintType enum has been replaced by a Score type specific method, to allow OptaPlanner to better support multilevel score types, for example HardMediumSoftScore and BendableScore.

You also no longer need to hack the API's to get a list of all ConstraintOcurrence's: the ConstraintMatch objects (and their totals per constraint) are available directly on the ScoreDirector API.

Drools Planner renames to OptaPlanner: Announcing www.optaplanner.org

noreply@blogger.com (Geoffrey De Smet) — Thu, 21 Mar 2013 18:35:00 +0000

We’re proud to announce the rename Drools Planner to OptaPlanner starting with version 6.0.0.Beta1. We’re also happy to unveil its new website: www.optaplanner.org.

OptaPlanner optimizes business resource usage. Every organization faces planning problems: provide products or services with a limited set of constrained resources (employees, assets, time and money). OptaPlanner optimizes such planning to do more business with less resources. Typical use cases include vehicle routing, employee rostering and equipment scheduling.

OptaPlanner is a lightweight, embeddable planning engine written in Java™. It helps normal Java™ programmers solve constraint satisfaction problems efficiently. Under the hood, it combines optimization heuristics and metaheuristics with very efficient score calculation.

OptaPlanner is open source software, released under the Apache Software License. It is 100% pure Java™, runs on the JVM and is available in the Maven Central Repository too.

For more information, visit the new website:

http://www.optaplanner.org

Why change the name?

OptaPlanner is the new name for Drools Planner. OptaPlanner is now standalone, but can still be optionally combined with the Drools rule engine for a powerful declarative approach to planning optimization.

OptaPlanner has graduated from the Drools project to become a top-level JBoss Community project.

OptaPlanner is not a fork of Drools Planner. We simply renamed it.
OptaPlanner (the planning engine) joins its siblings Drools (the rule engine) and jBPM (the workflow engine) in the KIE group.

Our commitment to Drools hasn't changed.

The efficient Drools rule engine is still the recommended way to do score calculation.
Alternative score calculation options, such as pure Java calculation (no Drools), also remain fully supported.

How will this affect your business?

From a business point of view, there's little or no change:

The mission remains unchanged:

We're still 100% committed to put business resource optimization in the hands of normal Java developers.

The license remains unchanged (Apache Software License 2.0). It's still the same open source license.
The release lifecycle remains unchanged: OptaPlanner is still released at the same time as Drools and jBPM.
Red Hat is considering support subscription offerings for OptaPlanner as part of its BRMS and BPM platforms.

A Tech Preview of OptaPlanner is targeted for BRMS 6.0.

What has changed?

The website has changed to http://www.optaplanner.org
The distributions artifacts have changed name:

Jar names changes:

drools-planner-core-*.jar is now optaplanner-core-*.jar
drools-planner-benchmark-*.jar is now optaplanner-benchmark-*.jar

Maven identification groupId's and artifactId's changes:

groupId org.drools.planner is now org.optaplanner
artifactId drools-planner-core is now optaplanner-core
artifactId drools-planner-benchmark is now optaplanner-benchmark

As usual, for more information see the Upgrade Recipe in the download zip.

The API's namespace has changed. As usual, see the upgrade recipe on how to deal with this efficiently.

Starting from 6.1.0.Final, OptaPlanner will have a 100% backwards compatible API.

OptaPlanner gets its own IRC channels on Freenode: #optaplanner and #optaplanner-dev

Instant Drools Starter : Pack Publishing (Jeremy Ary)

noreply@blogger.com (Mark Proctor) — Tue, 12 Mar 2013 14:58:00 +0000

We all start somewhere. My start with Drools came 5 years ago when I was tasked with maintaining some legacy rules and assisting with a new ground-up effort using the latest and greatest Drools release at the time. I dug through documentation, ordered every book I could find on the subject, and pestered Mark, Edson and others in the community willing to help way more than they probably cared for, but in the end, the community helped start me out with what I'd soon find to be my new obsession. Now, I feel like it's time for me to give something back.

If you're an architect, manager, or developer looking to evaluate or get started with Drools, you may find my new book, Drools Starter, to be a great way to get up and running quickly. I've done my best to compile all the basics needed to get a feel for working with the core engine into a brief, easy-to-digest guide. Here's some of what's covered inside:

Evaluate rules engines as a fit for your needs
Installing Drools and development tools
Authoring rule sets using the Drools Rule Language
Feeding information to your rules engine and evaluating rules
Understanding DRL syntax, operators, and functionality
Testing rules as a whole, individually, and for stability
Debugging the rule evaluation process visually and via logging
What modules make up the Drools system and the capabilities of each
Where to turn for more information and help

The book is currently available for pre-order (at a 20% discount!) over at Pack Publishing: http://www.packtpub.com/getting-started-with-drools/book

I owe a large thanks to the community in helping me on my way through the last several years, especially to those in IRC and the mailing list who've aided with numerous predicaments and design choices along the way. Particular thanks to Mark, Edson and the rest of the development team for continued work on a great product and a great community, but especially to the two of you for spending too many hours in conversation online and at conferences helping myself and others like me find their way.

Jeremy Ary (jary)

Automatic solution cloning in Planner

noreply@blogger.com (Geoffrey De Smet) — Thu, 14 Feb 2013 11:26:00 +0000

For Planner 6.0.0.Beta1, implementing the Solution's planning clone method is now optional. This means there's less boilerplate code to write. Also, because the planning clone method notoriously hard to write from scratch (most people just copy pasted the examples to avoid mistakes), it's now easier to get started with Planner too.

The out-of-the-box SolutionCloner works well for most use cases: it's fast, yet still does a few sanity checks to detect errors.

Custom solution cloning

You can still choose to roll your own solution cloning. Now, it's also documented what Planner expects you to do:

A planning clone of a Solution must fulfill these requirements:

The clone must represent the same planning problem. Usually it reuses the same instances of the problem facts and problem fact collections as the original.
The clone must use different, cloned instances of the entities and entity collections. Changes to the original Solution's entities must not effect its clone.

And there's also warning, in case you're using chained planning variables, for a common pitfall:
Cloning an entity with a chained variable is devious: a variable of an entity A might point to another entity B. If A is cloned, then it's variable must point to the clone of B, not the original B.

But don't worry about that: just use the default SolutionCloner, which will take care of all that for you.

Dropping JSR94

noreply@blogger.com (Mark Proctor) — Wed, 13 Feb 2013 23:30:00 +0000

We are thinking of dropping JSR94 support in the next release, especially as it doesn't align with our new approach to building rules - which is convention and configuration based, rather than api based.

If anyone has a good case for keeping JSR94, please leave a comment.

Design Patterns in Production Systems (Wolfgang Laun)

noreply@blogger.com (Mark Proctor) — Wed, 06 Feb 2013 21:43:00 +0000

Many thanks to Wolfgang Laun for making his extensive work available for all of us to benefit from. The free pdf is just a short registration page away:
https://engage.redhat.com/forms/rule-design-patterns

Scaling construction heuristics part 1: multiple variables

noreply@blogger.com (Geoffrey De Smet) — Wed, 16 Jan 2013 13:56:00 +0000

For Drools Planner 6.0, I am working on highly scalable construction heuristics. Furthermore, they 'll be far more flexible and optionally configurable. This post focuses on how multiple planning variables affect scalability.

In the curriculum course use case, the planning entity Lecture has a planning variable Period and a planning variable Room. That makes 2 planning variables per entity. For example, dataset comp07 has 434 lectures, 25 periods and 20 rooms.

Suppose we use the construction heuristic First Fit Decreasing (FFD) on that. Simply explained: FFD sorts the lectures in a queue, takes the first lecture from that queue and assigns it the best remaining Period and Room. It repeats this until all lectures are assigned.

What's wrong with the old FFD implementation?

If there are multiple variables, the old implementation will, for every lecture, try a combination of every period and every room. So, for every lecture, it will try a cartesian product of the period value set and the room value set. In comp07 it tries 25 periods * 20 rooms = 500 moves for each of the 434 lectures. Suppose I have 5 variables of 1 000 values each: that would make 1 000 000 000 000 000 moves per entity!

The new implementation now also supports an alternative: do a union instead: for every lecture, try every period and assign the period, then try every room and assign the room. In comp07 it tries 25 period + 20 rooms = 45 moves for each of the 434 lectures. With 5 variables of 1 000 values each, that would make only 5 000 moves per entity.

So how does this affect score results and performance?

Benchmark cartesianProduct vs union of multiple variables

Unsurprisingly, cartesianProduct has consistently better results than union (because it investigates much more combinations):

Union breaks more hard and soft constraints. But this is an unfair comparison: union took less time. So that leaves more time for local search to optimize those constraints.

If we look at the number of milliseconds to run both algorithms, we can clearly see that cartesianProduct takes much longer than union.

Especially if we look at the scalability graph, we can see a clear scalability problem with cartesianProduct, unlike with union:

Here, there are only with 2 planning variables (period and room). More planning variables has even worse scalability.

So what can Local Search do with that extra time? Let's give both configurations 2 minutes, so local search gets whatever time is left after the construction heuristic has finished:

For this dataset scale, there's no clear winner in this case: they are competitive. If we scale out, I imagine we 'll see union as the clear winner. So if my dataset is small/medium and I have an execution time of at least 1 minute, I might go for cartesianProduct. Otherwise, I 'd prefer union. In any case, I 'd use the Drools Planner's benchmarker toolkit to help me decide that.

Interested in the benchmark's details? Take a look at the full benchmark report here.

Life Beyond Rete - R.I.P Rete 2013 :)

noreply@blogger.com (Mark Proctor) — Wed, 02 Jan 2013 18:13:00 +0000

I'm just putting the final touches onto my new algorithm. It merges concepts from Leaps, Collection Oriented Match and Left/Right unlinking, as well as a few ideas of my own. The code is committed, but I'm just getting accumulate to work and writting some more tests. I'll do a full blog in a week or so, writting about it in more detail, hopefully accompanied with an alpha for people to play with.

The algorithm addresses the greedy and wasteful nature of Rete. This will make it suitable for more constrained environments, such as mobile devices, or browsers if we do a JS port with GWT. Further it's been designed with multi-core utilisation in mind - although I haven't implemented that yet.

For those with an understanding of the terminologies, here is a bullet point list of what I've done so far.

Rule unlinking

With segments to preserve sharing. Bit masks used for right input and segments, for efficient checking.
A Segment has it's bit set, when all right inputs have their bit set.
A rule is linked in, when each segment has it's bit set.
No beta evaluation happens until a rule is both fully linked in an popped of the agenda (see lazy rule evaluation)
A linked rule can be unlinked, when any of right inputs has no data

All full and partial join data is preserved.

avoids re-calculation when rule is re-linked
Stops further wasted join attempts until the rule is likely to fire

GC algorithm is needed, so joins can be removed from memory if not used for some time.

I suspect we could use arc consistency to further delay when a bit is set, rather than simple the existing of a right input

Lazy rule evaluation

Rule's beta network is not evaluated when linked. Instead it's added to the priority queue, only when it pops do we evaluate it's beta network

Set Oriented propagations

All insert, update and deletes are staged for the right inputs, until rule is evaluated.
Beta network evaluation starts at the root

All inset/update/delete's are processed together resulting in a set of tuples to be propagated to the next node
The set of tuples has separate lists for inserted, updated, deleted tuples.

Ensures course grained node evaluation, ideal for multi-core scheduling.
Single pass propagation, instead of typical Rete which depth search thrashes the network.
Note we do not yet do collection oriented match, which collapses the match space in a node.

While we borrowed the collection propagation concept, the defragmentation process of collection oriented match needs a lot more thought, as it has downsides.
While not done yet, we will now be able to support set oriented executions, as well as propagations. Ideas for this are outlined here, https://community.jboss.org/wiki/RuleExecutionSemantics, inspired by DADO.

Modify in place/Differential Update

Modifies are real, instead of a retract + assert
Allows for compensation "undo" actions, as we know what really was deleted and what was updated.
Preserves objects, to avoid GC hit.

Property Reactive

Patterns can listen and react to specific property changes

Think of it as a property change listener, rather than the current class change listener
Defaults to listen to constrained fields, users may override what they do or don't listen to.
Uses bit masks to keep it efficient

Tree based graphs

Retracts simply need to iterate the graph
Allows for efficient "modify in place"

Subnetwork support

not, exists, accumulates can supported nested groups and patterns
Is supported as part of the single pass network evaluation

Our tuple set reaches the left input, and then recursively evaluates the subetnworks(s). This then eventually results in a single set of tuples again, which is applied to our current node, resulting in a single set to propagate to the child.

While not complete, here are some TODO items I can think of, to give an idea of near and longer term ideas:

More efficient sub-networking

The new design allows for more efficient execution within subnetworks, but we have yet to take advantage of this.

GC Joins

Allow joins to be GC'd after a period of time, if they are not used, but also must support recreation while not invalidating the execution sequence of rules (i.e. a rule must not fire again, if it's already fired)

Different network topologies

Rete network's always join from left to right, this is not always efficient. Treat and Gator networks look at how different topologies can reduce the number of join attempts, it can also improve sharing with our new segmentation based network.

Multi-core work

The design now is already queued based, and supports coarse grained units of work. We now need to start creating the thread model and better isolating and separating the alpha network propagation process. This involves refactoring our existing locking model.
Efficient testing of overlapping rules is needed - i.e does one rule share segment with another rule. This will allow us to evaluate rules, without sync points.

Intelligent Linking

At the moment linking is done by setting a bit, when a right input receives a single fact. Arc consistency can be used to further delay this linking process, only linking in a rule segment and also a rule, when arc consistency is achieved.

MVCC and Transactions

The propagation model should support Multi-Version Concurrent Control. This will be necessary to get better multi-core support, and it will enable transactions support.

R.I.P.

RETE 2013 :)

Rolo The Robot says: Happy New Year!

noreply@blogger.com (salaboy) — Sat, 29 Dec 2012 11:17:00 +0000

Hi Everyone! This is probably my last post of the year and in this occasion I want to share with you all a side project that I've being working on my spare time with my father. In less than 10 days we manage to build a small robot which runs all its logic inside the Drools Rule Engine. This first step main goal was to prove that it is possible to build a low cost robot which will be entirely controlled by the rule engine and the CEP features provided by Drools Fusion. We didn't include any process execution in this first stage, but it is definitely on the roadmap. This post briefly explains what we have now working and what's planned for the future, because this is just the beginning. The interesting side of the project is to make the robot completely autonomous, which means that it will run entirely on its own and without the need to be connected to a computer or to a power outlet in the wall.

Introduction

We started building this first prototype with the following goals in mind:

Demonstrate that the Drools & jBPM Platform can help us to build a reliable and declarative environment to code the robot internal knowledge.
Demonstrate that a robot can be constructed on top of the Rule & Process Engine in a reduced and portable platform. Some important points from our perspective are:
- It needs to run without an external computer
- It needs to be autonomous and run on batteries to have freedom of mobility
- It can be monitored and contacted via wireless
- It needs to react in near real time and process information without requiring long periods of time. We are doing the tests with 100 millisecond (because that's more than enough in this stage) lapses now but the performance can be improved to support lower latency.
Test different hardware options to decide which are the best components to use to build different types of robots
Push the limits and mix the Rule/Process Engine arena with the Hardware/Electronics/Robotics arena.
Incrementally build a framework to speed up the initial steps
and of course, make it open source to improve collaboration and to join forces with other people which are interested in the same topics.

Hardware

: Rolo!

My father (Jose Salatino), "the electronic geek" help me with all the hardware side of the robot. I've started looking at the Lego NXT and WEDO platforms to see if we can reuse some of the cool things that they have designed, but the NXT runs with J2ME and it's old at this point. I'm looking forward to see if they release something new soon. The Lego WEDO and Power Functions looks promising, but they have several limitations such as: reduced number of devices that you can handle via the USB port and there are some expensive pieces that you need to get if you want to make it work. When my father started playing with Arduino we find a lot of advantages which help us to get everything working in almost no time. In the other hand the Lego Motor & Sensors provide us a great and scalable environment to create advanced prototypes. For that reason, we choose to use Arduino as a central Hub to control a set of Sensor, Motors and Actuators, no matter if they are Lego or not.

The following figure shows the wiring between the different components that we are using, most of the components can be changed without affecting the software architecture:

: Hardware Wiring

This list summarize the list of components that we are using, please note that there are a lot of things to improve so this infrastructure is in no way set in stone:

1 x Raspberry Pi Model B
1 x Arduino Uno
2 x Lego NXT Servo Motor
1 x SR04 Ultra Sonic Sensor (Distance Sensor)
1 x SG90 180 Servo Motor
2 Battery Packs (10 AA batteries) -> we are working on this, don't worry ;)
1 x USB Wireless Dongle
1 x LDR Sensor (Light Sensor)

Hardware Roadmap

From the Hardware perspective there are a lot of things to do. We will start researching about the I2C protocol to replace all the serial communications. We know that I2C is the way to go, but we didn't had time yet to do all the necessary tests. We currently have a hardware/physical limitation about the number of devices that we can set up. We want to push the platform limits so we will be looking forward to add more motors and more sensors to increase the robot complexity and see how far we can go.

Software

From the software perspective we have a bunch of things to solve, but this section gives a quick overview about what has been done until now. We need to understand that the Raspberry Pi is not a PC, it's an ARM machine, which is a completely different infrastructure. For Java that's not supposed to be a problem, but it is. When you want to access the serial port or use the USB port to transmit data, you will start facing common issues about native libraries which are not compiled for the ARM platform. Once we manage to solve those issues we need to find a way to interact with the Arduino Board which is programmed in C/C++. Luckily for us there is software called Firmata which externalise via the Serial port the whole board. Using this software we can read and write digital/analog information from the board pins. This helps us a lot, because we will write a standard software inside the Arduino which will allow us to write/read all the information that we need into the board to control the motors and read the sensors. Unfortunately, as every standard we hit a non covered sensor (SR04 - UltraSonic Sensor), and for that reason we provided a slightly modified version of the Firmata Sketch, which can be found inside the project source repository. From the Java Perspective, there is a library called processing (Processing is an open source programming language and environment for people who want to create images, animations, and interactions) which has a number of sub libraries, one of them for interacting with Firmata. I borrowed two classes from Processing in order to customize to my particular needs. From the beginning I wanted to use Processing because believe that it has a lot of potential to be mixed with the Process and Rules Engine, but this initial stage is not taking advantage of it.

The following figure shows from a high level perspective the different software components that runs in order to bring Rolo to life:

: Software Components

As you can see, the Rolo Server expose and recieve information via JMS which allows us to build a Monitor to see the information and send more imperative commands or information about the world to the robot. Rolo Server is basically a Drools/jBPM Knowledge Session now, but a more robust schema with multiple sessions for different purpose will be adopted in future stages.

The Rules right now have access to all the Motors and Sensors information allowing us to write rules using those values. All the sensors input data are considered as events and for this reason we can use all the Drools Fusion temporal operators.

The following two rules are simple examples about what is being done inside the robot right now:


rule "Something too close - Robot Go Back"
   when
        $r: RoloTheRobot()
        $m: Motor(  )
        UltraSonicSensor( $sensor: name )
        $n: Number( doubleValue < 30) from accumulate (
                    DistanceReport( sensorName == $sensor, $d: distance )
                                    over window:time( 300ms )
                                    from entry-point "distance-sensor", average($d))

   then
       notifications.write("Process-SOMETHING_TOO_CLOSE:"+$n);
       $m.start(120, DIRECTION.BACKWARD);
       Match item = ( Match ) kcontext.getMatch();
              final Motor motor = $m;
              final HornetQSessionWriter notif = notifications;
              ((AgendaItem)item).setActivationUnMatchListener( new ActivationUnMatchListener() {

                    public void unMatch(Session session,
                                        Match match) {
                        System.out.println(" Stop Motor");

                        motor.stop();
                        try{
                            notif.write("Stopping Motor because avg over: 30");
                        } catch(Exception e){
                            System.out.println("ERROR sending notification!!!");
                        }

                   }
                } );
end

This rule checks the average of the distance received from a Distance Sensor (in this case the UltraSonic Sensor) in the case that the distance is less than 30cm in the last 300ms all the motors will be started at a fixed speed to move away from that object. This allows us to be sure that there is something in front of the robot instead of reacting in the first measure that matches the condition. Different functions can be used to correct wrong reads from the sensors and to improve the overall performance. Notice that after starting the motor we are registering an ActivationUnMatchListener, this will cause that as soon as the Rule doesn't match anymore the motor will be stopped. You will see in the video, that the robot will go backward until the average received from the Distance Sensor in the last 300ms is over 30 cm.

There is another rule which use the Light Sensor to know how to go out from dark places.

Software Roadmap

After a well deserved holidays, I will be working on improving the code base, to allow to run all the software without the need to have an Arduino Board or any specific hardware. The main idea is to have an environment where we can simulate virtual motors and sensors. This will allows us to improve the development of the software without being tied to the hardware improvements. This will also allow you to collaborate with the project, if I get enough collaborations I can do weekly videos about how the robot behaves using your contributions :)

So, take the following list as a brain dump of the things that I need to do on the project:

Improve the infrastructural code: JMS messages encoding, Monitor App, Simulation App
Create more rules and processes to enable Rolo to do different things such as: recognize the environment/room where its running, interact with different objects,
Mock a coordinate system and a model store different objects recognized from the environment.
Use processing to draw in real time what is being sensed by Rolo in a 3D environment
Enable Rolo to ask questions using the Human Task Services provided by jBPM
Define the requirements for actuators and how to use them
Video Streaming and image analysis

Video

Finally, let me introduce you: Rolo The Robot!

Notice in the last 20 seconds of the video you can see the Rolo Client/Monitor application which shows us all the notifications that are being sent from the robot. You can see a small control panel which allows us to send some commands and also see the values that are being captured from the sensors.

Rolo says: Happy New Year to you all!

Stay tuned!

jBPM Console NG (Update): Rules + Processes + Events

noreply@blogger.com (salaboy) — Mon, 17 Dec 2012 00:12:00 +0000

Hi everyone! I'm back with another update about the jBPM Console NG. Yesterday we did a quick demo about the console current features in the JBUG London meetup. Today I've decided to explain the demo in more depth and also explain the last slides from the presentation which describe some scenarios where events and rules influence the execution of our business processes.

Introduction

The main idea of the demo is to show how rules, processes and events can be used to monitor our business processes and influence their execution. In order to understand the runtime behavior we need to obviously understand how Rules and Events works, but I will start explaining the business use case first in order to explain what we are trying to achieve.

The Business Process that we want to execute looks like the following image:

This is just a normal process, it includes Human Interactions and System Interactions. We will handle the Human Interactions with the Human Task Services and the System to System interactions will be handled with different WorkItemHandlers implementations.

The process is about releasing artifacts. In order to make a release the files from an specific artifact needs to be staged. We have three directories where we will move the files to be released and they will be processed accordingly. Basically, we will pick a set of files from a repository that has the following directory structure:

: Directory Structure

The sequence will be: Origin (where the original files will be placed for the release process) -> Stage (reviewed by a Person) -> Test (automatically tested) -> Production.

Notice that if the automatic tests fails a special path will be followed and a Person will be in charge of fixing the issues and move the files back to the Staging area.

Keeping our process as simple as possible

We don't want to complicate our business process, we want to keep the process definition as clear and simple as possible. We don't want to add tons of activities to check different situations that doesn't describe the normal flow of actions. But at the same time we want to enforce some extra requirements and deal with exceptional business situations. For recognizing situations where we want to enforce different business policies or recognize business exceptions we can start using rules. If we want to recognize situations that involves time intervals we can include Fusion into the picture.

As I've explained in previous posts, there are several rules to analyze our processes executions using Rules, but from a very high-level perspective we can do the following:

Analyze a single process and the process contextual information to execute some actions or influence the process state
Analyze a group of processes running in the same context as a logical group and execute an action that can be related with one particular instance, create one or a group of new new instances, terminate/abort one or a group of running instances, create one or a group of human tasks, or execute one or a set of actions.

To demonstrate the different things that you can do we have chosen three different things that we can do without adding more complexity to our process definition:

If an instance of the process go 2 or more times through the Fix Issues branch, we want to get a warning or notify someone about this situation to take an action. Imagine the pain of doing this kind of checks inside the business process, probably adding a new process variable to check the amount of executions of each path, a real nightmare that complicates the process definition.

Paths and Activities Evaluations
If an instance is doing a release with a set of files or pointing to an specific repository, we must not allow two process instances working with the same resources. If you think about this restriction that involves multiple process instances then it is clear that the logic of checking those restrictions cannot be placed inside a process definition, because it's not a restriction that will be applied per instance. If you think about this kind of situations, you will see that there a lot of similar cases where you can apply more intelligent restrictions to a set of process instances. The main problem is that if we have a "Normal/Old" process engine your application will need to handle those kind of things, or once again you will need to start doing some hacks in order to make that work. Most of the time using traditional BPMSs you don't even think about how to handle these scenarios, because the tooling doesn't even support them.

Multi Process Instance Evaluations
In some situations we want to solve cross cutting concerns that are solved in multiple processes in the same way. Sometimes we have tasks that are done in several business processes, but we don't want to include the task as part of the process definition because it's a generic task that its not related with the business goal of that business process, but it's related with the work that needs to be done to keep things running. In such cases, we can create an Ad-Hoc task to deal a particular situation. In this case the example shows a task that is being created to improve the performance of an automated task if the execution takes longer than we have expected. We can define the SLAs using rules and dynamically create a human task if it's needed.

Ad-Hoc Task

jBPM Console NG - technical side

Let's analyze from the technical perspective how the infrastructure should provide us a way to handle situations likes the ones described before. Before going into the rules that are identifying and reacting on different situations, we need to understand how to generate the data that the rule engine will use.

First of all we need to notify the Rule Engine about the Process Instances, so it handle them as facts. For this reason we attach the following process event listener to our sessions:

https://github.com/droolsjbpm/jbpm/blob/master/jbpm-services/droolsjbpm-knowledge-services/src/main/java/org/droolsjbpm/services/impl/event/listeners/CDIRuleAwareProcessEventListener.java

This process event listener is in charge of inserting, updating and retracting the Process Instance from the Knowledge Session where the process is running. It also keep up to date the process variables that are modified inside the process. This listener also generate and insert Drools Fusion events that can be used for temporal reasoning.

The expected results when we attach this ProcessEventListener to our sessions is:

Every time that we create a process instance , the Process Instance object will be available to the rule engine to create rules about it.
When a process instance is completed it is automatically retracted from the rule engine context
When a process variable is modified/updated the Process Instance fact is updated as well
Every time that an activity is executed "Drools Fusion" events are created and inserted into the session before and after the task is executed. We as users have the responsibility to define these types as events, so the engine can tag them with the correspondant timestamp (Look at the rules file).

Inside the session that have attached this listener we will be able to:

Write rules about Process Instances and their internal status, including process variables
Write rules that identify situations where we want to measure time between different activities of the same process or a group of processes
Influence the business processes execution based on different scenarios
If we insert into the session more business context, we will be able to mix all the information that is being generated by the processes execution with our business context to recognize more advanced scenarios
Mix all of the above

Resources and Git Backend

One more important thing if you want to try this alpha version, is to understand that we are now picking up all the resources that are being used by the runtime from a Git Repository. This means that our backend repository in this case is github.com. We store all our assets in this repository, and we build up different sessions using the resources located in the remote repository. This gives us a lot of advantages, but the integration is not finished yet. In the future you will be able to point to different repositories and fetch resources on demand to build new runtimes. For now you need to understand that Forms, Processes, Rules and all the configuration resources are being picked up from a remote repository, abstracting our application from where the resources are stored.

Rules, Processes & Events

Once we have all the data inside our session we can start writing our rules.

The complete rules file used for this demo can be found here:

https://github.com/guvnorngtestuser1/jbpm-console-ng-playground/blob/master/examples/release/process_rules.drl

Here are some things that we need to understand from this drl file:

Event Declarations: We need to inform the rule engine which facts will be treated as Events. Notice the first lines after the imports:
declare ProcessStartedEvent

@role(event)

end
In this case we are defining that all the insertion of ProcessStartedEvent needs to be handled as events, which are a special type of facts.
We can make services available for the rules to use. For this example I'm injecting the services as globals:
global RulesNotificationService rulesNotificationService;

global TaskServiceEntryPoint taskService;The TaskServiceEntryPoint will allow us to create and manage tasks from rules. The RulesNotificationService is exposing to the outside world the rules execution. It's a quick way to notify the users about certain situations. You can think about it as a simple log service about what is happening inside our sessions.
Then you can write rules about Processes and the Events generated by the processes:
rule "Fix Issues Task pending for more than 30 seconds"

when

$w1: WorkflowProcessInstanceImpl($id: id)

$onEntry: ProcessNodeTriggeredEvent(
processInstance.id == $id,
$nid: nodeInstance.id,
nodeInstance.nodeName == "Fix Issues") from entry-point "process-events"

$onExit: ProcessNodeLeftEvent(
this after[30s] $onEntry,
processInstance.id == $id,
nodeInstance.id == $nid,
nodeInstance.nodeName == "Fix Issues") from entry-point "process-events"
then....So this rule is matching situations where a particular node inside (Fix Issues) of our business processes is taking more than 30 seconds to be executed. Notice that the process instance events are being inserted in a special entry-point called "process-events". I suggest you to take a look at the other rules that are being analyzed inside the demo, so you can get in idea about what kind of things can be done in this environment.

DEMO

jBPM Console NG update 14/12/2012 from salaboy on Vimeo.

Full Presentation at JBUG London

Stay tuned for more updates about the console and the book!

New Meetup Scheduled @ -> Barcelona -> http://salaboy.com/2012/12/16/barcelona-jug-jbpm5-developer-guide-presentation-191212/

Barcelona JUG - jBPM5 Developer Guide Presentation (19/12/12)

noreply@blogger.com (salaboy) — Sun, 16 Dec 2012 23:31:00 +0000

Hi everyone, I'm going to give a presentation in Barcelona about the jBPM5 Developer Guide book. There is no defined venue yet, but it will be next Wednesday (19th) at 7pm somewhere in the city. I will keep you posted! If you are interested to attend please drop me a comment so we can make the necessary adjustments. This will be a Barcelona JUG meetup, so feel free to invite as many friends as you want and please help us to spread the word.

Here are some links from the Barcelona JUG Group that you can follow to see updates about this and future meetups:

Google groups - http://bit.ly/BarcelonaJUG

Blog - http://barcelonajug.blogspot.com.es/

LinkedIN - http://www.linkedin.com/groups?gid=4115806

Twitter - http://twitter.com/BarcelonaJUG

Facebook - http://facebook.com/BarcelonaJUG

Update

Hi everyone, the meetup for tomorrow is confirmed and we now have a place confirmed. The meetup will take place in the Facultad de Informatica de Barcelona:

Edifici B6 del Campus Nord C/Jordi Girona Salgado,1-3 08034 BARCELONA Espanya

the talk will start at 7 pm, so see you there with all your friends!

Spanish:

Hola a todos! Estare en Barcelona presentando el libro jBPM5 Developer Guide. Todavia no hay sitio definido, pero en el transcurso de mañana estaremos publicando el lugar. Estamos seguros de que sera el Miercoles 19 de Diciembre en algun lado de la ciudad a las 7pm. El evento esta organizado por Barcelona JUG por eso sientanse libres de invitar a cuantos amigos pueda y ayudenos a difundir la palabra.

Actualizacion:

El evento y el lugar esta confirmado!

Nos vemos mañana miércoles 7pm a las 7pm!! En el Edicio A6, Aula 102 de la Facultad de Informática de Barcelona!

Edifici B6 del Campus Nord C/Jordi Girona Salgado,1-3 08034 BARCELONA Espanya

Lleven a sus amigos!

6.0 Alpha - Annotation Driven development with Multi Version Loading

noreply@blogger.com (Mark Proctor) — Sat, 15 Dec 2012 09:00:00 +0000

Drools & jBPM 6.0 alpha should be out end of next week. 6.0 introduces convention based projects that remove the need for boiler plate code - literally just drop in the drl or bpmn2 and get going. Further we now allow rules and processes to be published as maven artifacts, in maven repositories. These artifacts can either be resolve via the classpath or downloaded dynamically on the fly. We even support out of the box side by side version loading, via the maven ReleaseId conventions.

As a little taster here is a new screenshot showing the annotation driven development. The lines below are all that's needed to dynamically load a module from a local or remote maven repository and start working with it. KieSession is the new, shorter name, for StatefulKnowlegeSession. Kie is an acronym for "Knowledge Is Everything", but I'll talk about Kie in another blog, expect to start hearing a lot about it soon :)

And here is a complete example screen shot. Create the drl, define the kmodule and start using them.

(click image to enlarge)

Score flexibility in Planner, shown with vehicle routing

noreply@blogger.com (Geoffrey De Smet) — Fri, 14 Dec 2012 08:40:00 +0000

Do we want to minimize distance or minimize time? Should trucks return to their depot after delivering their items?
It depends on what's best for your business. Luckily, changing the score function in Planner is easy, as shown in this demo.

jBPM Designer 2.4.0.Final released!

noreply@blogger.com (Tihomir Surdilovic) — Tue, 27 Nov 2012 19:22:00 +0000

We are very happy to announce a new release 2.4.0.Final of jBPM Designer, the Web-based Business Process Editor for jBPM 5.
Here is an overview of new features and most notable bug fixes in this release:

New Features

Revamp of Process and Task Form editing support
Business Process Simulation !!!
Local History support
Workflow Patterns support
Notifications and Deadline support

Notable Bug Fixes

You can download jBPM Designer version 2.4.0.Final from Sourceforge. If you are upgrading from an older Designer version, make sure to clear your browser cache before start using the new one.
You can clone jBPM Designer or just browser its source at GitHub.

Roadmap
For the next release we will strongly focus on

Add enhancements to Process Simulation capabilities
“Smart Properties” – more usable ways for users to enter in execution properties to their models
Alternative asset storage options
Overall usability enhancements

jBPM Designer is open-source and of course free! If you would like to be part of Designer development and discussions or just want to ask questions feel free to talk to us on the User Form, the Mailing List, or IRC.

You can also follow the latest news about the jBPM Designer on it’s Blog.

Enjoy

jBPM Console NG - Alpha Dev Access

noreply@blogger.com (salaboy) — Tue, 27 Nov 2012 10:07:00 +0000

Hi everyone! I'm writing this post to introduce the jBPM Console NG project which will provide a new integrated workbench for handling process related activities. We are now in a very initial stage of development and we are looking for contributors. We know that there are a lot of companies out there implementing their own solutions and at this point we encourage you all to give us feedback about the direction that we are picking for the BPM tooling. As usual, this tooling will be integrated with all the Drools and Guvnor Tooling to provide an integrated Knowledge Development Environment.

: jBPM Console NG

Introduction

As always, we are developing the jBPM Console NG in a public github repository: https://github.com/droolsjbpm/jbpm-console-ng

You can clone this repository, build the source code and deploy the jBPM Console NG in your own container following the next steps:

1) git clone https://github.com/droolsjbpm/jbpm-console-ng.git

2) cd jbpm-console-ng

3) mvn clean install

4) cd jbpm-console-ng-showcase

5) mvn gwt:run -> This will display the GWT Development Mode console which will give you an URL to access via your Browser (for development purposes you need to use Firefox which provides a Development GWT Plugin that allows us to Debug the application)

Technology

The application is being developed using Uberfire which is based on GWT (Google Web Toolkit), Errai and CDI. This mix of technologies gives us the ultimate environment to build flexible applications using a rock solid component model. I will be posting some examples showing how to get started to create new panels and add customizations to the existing code base shortly, but feel free to clone/fork the repository to take a look at the current status.

Goals

The main goal behind the application is to provide an integrated environment to discover, design, deploy, execute, monitor and improve our business processes. In order to provide all this functionality we have started the development integrating our existing components inside the Uberfire infrastructure.

There is an ongoing effort to integrate the jBPM Process Designer inside this platform, but I've started working on the Process Runtime Panels and in the Task Lists with the help of Maciej.

The following screenshots shows the current status of the application:

Home Screen

The home screen shows us important information about the things that the user is enabled to do. The jBPM Lifecycle chart allows the use to select in which phase he/she wants to work. Right now I'm focused on improving the "Work" stage as it's being shown in the following screenshots.

: Home Screen

The home screen also contains a suggestion box that allows you to quickly type different "Commands" to access the different sections of the application. In order to return to the Home Screen, we can use the shortcut CTRL+H.

Tasks List

The Tasks List screen will allows us to interact with the tasks assigned to us or to the groups where we are included. As you can notice in the previous screen, my user (salaboy) was included inside the [Writer] group. This means that all the Tasks associated to the Writer group will appear in my personal task list. Notice that for each row inside the list we will have a set of actions to interact with each task. The following screenshot shows the Start button inside the Actions column, we can also edit/view the Task Details and we can also access to work on that particular task via it associated Task Form.

: Tasks List

Quick Tasks Creation

Clicking in the Create New Task button, we will be able to create a new Task for us or for other person inside the organization. The task will be created assigned to us, but we can forward the task later. Notice that we can also create a Quick Task, this means that the task will be automatically started and can be used as a simple TODO task. No matter where we are in the application we can use the shortcut CTRL+T to create a new task.

: Quick Task Creation

Task Details

The Task Details popup allows us to see the most important information about the a particular task. If we want to access to a more detailed view about that particular task we can click the Full button which will open more panels related with that task. Notice that This task is not associated with any business processes, but for those variables which are associated with a business process instance, we can access to see the process instance details using the "Process Instance Details" button on the bottom.

: Task Details

Forms

The current version allows us to interact with tasks via Task Forms which are dynamically generated based on the task content and the expected outputs. This task is already in progress, and for that reason you can see the Complete button on the bottom of the form. If the task is in a different state, different buttons will be displayed. As you can see the Save button will allow the user to store intermediate steps of the information that is being filled up inside the form. The Full button can be used to see the form with more contextual data, like for example Task Attachments or Task Comments.

: Task Form (Based on a Template)

Process Management

The Process Management panels will allows us to see all the available Process Definitions and it will allows us to create new Process Instances. As you can see in the following screenshot, you will be able to inspect the Process Definition Details to see the process diagram and relevant information about each process.

: Process Management

Process Instance Details

Inside the Process Instance Details you will be able to see the current status of the Process Variables, the activities that are being executed and also the Log for that particular instance.

: Process Instance Details

Signaling Events

From the Process Instance List you will be able to signal events. The Events List will be retrieved based on the process definition and the Signal Ref suggestion box list you all the events related with the selected Process Instance.

: Signal Events

Roadmap

During the following months we will be working on polishing the current panels and services behind the application to provide an error free environment that allows you to execute your business processes and interact with the Human Task Services. During this initial phase of development we are looking forward to improve the user experience, and for this reason we encourage you to try the latest source code and let us know what you think. This initial version can also be deployed in the cloud, like for example OpenShift. We believe that this will help a lot new users that want to try out an existing installation.

There a lot of things that needs to be done, so take a look at the following section because if you want to get involved with the development of an open source tooling this is a very good opportunity to learn and to join the project.

Contributions

The following list is a set of things that can be done by Java Developers and doesn't require any advanced knowledge about the technology that we are using. You will see that the technology stack that we are using is extremely simple and agile:

Task Comments Panels
Task Attachments Panels
Shortcuts Mappings Panels
Notifications Panels
Avatar and Meta information about users and groups Administration Panels
Domain Specific Suggestions Phrases Administration Panels
I18N Translations (We already have Spanish (es_AR) and English, so if you are a native speaker of a different language feel free to drop us a line)
Extending the GWT DataGrid component to support prioritized lists (Knowledge about GWT is required)
Create a Custom GWT Calendar Component to display the pending tasks in a Calendar. (Knowledge about GWT required)
Experiment with m-gwt (http://www.m-gwt.com/) (Knowledge about GWT and motivation to learn m-gwt is required)
Any idea that you may have and want to propose

Drop us a line with your ideas/requirements, we are very open to guide all the interested in doing contributions to learn what they need in order to get started. I will be posting some videos about how to create a simple panel and about how the internal services are working on the next few days, but feel free to ask questions if you are interested in this development. You already know where to find me :)

jBPM5 Developer Guide Official Presentation @London

noreply@blogger.com (salaboy) — Mon, 26 Nov 2012 11:23:00 +0000

Hi all, with the book almost being printed out, we have organized an oficial presentation with the help of the JBug London. We (Esteban Aliverti and I - "Salaboy") will be giving a talk about the book the 12th of December. Seats are limited, so make sure to reserve yours today:

http://www.meetup.com/JBoss-User-Group/events/85267232/

We will be giving away a free copy of the book to the attendee who makes the more interesting questions during the talk. Feel free to drop us a line with comments or expectations about the talk. You can start looking at the examples provided with the book here:

https://github.com/Salaboy/jBPM5-Developer-Guide/tree/1.0.Final

We will be posting a detailed agenda about the presentation shortly.

Stay Tuned!

PS: you can follow us on twitter: @salaboy and @ilesteban

JBUGs Sydney & Melbourne 19th & 20th November 2012

noreply@blogger.com (Kris Verlaenen) — Fri, 16 Nov 2012 09:22:00 +0000

I'm visiting Australia next week, and I'll be giving two JBUG presentations:

in Sydney on Monday November 19th
in Melbourne on Tuesday November 20th

I'll give a quick jBPM overview and focus on some of the new features that we're developing and some of the changes you'll see in the near future.

Important: Followed by pizza and drinks after each session ! :)

So if you're in the vicinity, feel free to join us. Registration is necessary.

Hope to see you there !

Drools & jBPM

Backward Chaining and Reactive Transitive Closures with Drools

Drools and Guvnor Beta3 Video

Creating your own Drools and jBPM Persistence with Infinispan

London JBUG May Event - What's new in Drools 6.0 (22nd May 2013)

London JBUG May Event - What's new in Drools 6.0

Presentation

Speaker

Agenda

Lightning Talks

Drools and jBPM talks at JUDCon:2013 United States

IntelliFest Oct 2013 - San Diego

International Conferenceon Reasoning Technologies

October 7-11 • Bahia Resort Hotel

San Diego, CA • USA

IntelliFest returns to the charming Bahia Hotel for 2013! Join us for a full program featuring:

Topics include but are not limited to:

Google Summer of Code 2013

Try the jBPM Console NG (Beta)! (for developers)

Introduction

Working with the Source Code

Running the application in Hosted Mode

Running the application in JBoss AS 7

On Openshift

The Application

Contributions

Score DRL: faster and easier in OptaPlanner

Faster

How does the average calculate count scale?

Easier

Drools Planner renames to OptaPlanner: Announcing www.optaplanner.org

Why change the name?

How will this affect your business?

What has changed?

Instant Drools Starter : Pack Publishing (Jeremy Ary)

Automatic solution cloning in Planner

Custom solution cloning

Dropping JSR94

Design Patterns in Production Systems (Wolfgang Laun)

Scaling construction heuristics part 1: multiple variables

What's wrong with the old FFD implementation?

Benchmark cartesianProduct vs union of multiple variables

Life Beyond Rete - R.I.P Rete 2013 :)

Rolo The Robot says: Happy New Year!

Introduction

Hardware

Hardware Roadmap

Software

Software Roadmap

Video

jBPM Console NG (Update): Rules + Processes + Events

Introduction

Keeping our process as simple as possible

jBPM Console NG - technical side

Resources and Git Backend

Rules, Processes & Events

DEMO

Full Presentation at JBUG London

Barcelona JUG - jBPM5 Developer Guide Presentation (19/12/12)

Update

Spanish:

6.0 Alpha - Annotation Driven development with Multi Version Loading

Score flexibility in Planner, shown with vehicle routing

jBPM Designer 2.4.0.Final released!

jBPM Console NG - Alpha Dev Access

Introduction

Technology

Goals

Home Screen

Tasks List

Quick Tasks Creation

Task Details

Forms

Process Management

Process Instance Details

Signaling Events

Roadmap

Contributions

jBPM5 Developer Guide Official Presentation @London

JBUGs Sydney & Melbourne 19th & 20th November 2012

International Conference
on Reasoning Technologies