OpenWFEru 0.9.6 released

The talk at the TLUG went well : not too much people were sleeping. The beer at the nomikai that followed went (down) even better. I will make the slides available soon.

I just released OpenWFEru 0.9.6.

The main addition is a bunch of Participants and Listeners. Participants ‘participate’ to business processes and listeners ‘listen’ to workitems as they come back from participants (some of those workitems may be LaunchItems, requesting the launch of a new Process instance).

OpenWFEru 0.9.6 features FileParticipant (+FileListener), SocketParticipant (+SocketListener) and SqsParticipant (+SqsListener). SQS stands for “Amazon Simple Queue Service”. In my next blog post, I’ll detail what stands behind this.

Alain helped me use Rote‘s ruby syntax trick, check out the quickstart for the colorful result.

talking at the tlug

I’ll be talking about OpenWFEru, Ruby workflow and BPM (technical point of view) tomorrow afternoon at the TLUG technical meeting of march.

Thanks to Zev and his team for this lively Linux User Group they are supporting.

quickstart

I’ve written a new quickstart for OpenWFEru.

In one file, it shows a minimum of OpenWFEru : enumerating the participants in an organization (by registering them in the workflow engine), establishing a process definition and launching it (via a LaunchItem).

The participants demonstrated are simple block participants, very easily understandable by Ruby developers.

The process is just launched once, that doesn’t do much justice to the process execution engine which is meant to track more than one of those.

Persistency is not demonstrated within this quickstart example. If you need a further example using a persistent engine and persistent participants, have a look at Mano’s tracker.

I’ll soon expand that quickstart page with details about what is going in this openwferu.rb source file.

Feedback is welcome on the users mailing list.

implicit “process-definition”

Until now, you had to do

class IssueTracking2 < OpenWFE::ProcessDefinition
    def make
        process_definition :name => "IssueTracking", :revision => "2" do
            cursor do
                participant :qa_team
                participant :dev_team
                participant :customer_team
            end
        end
    end
end

engine.launch(IssueTracking2)
#...

With the upcoming OpenWFEru 0.9.6, you’ll simply do

class IssueTracking2 < OpenWFE::ProcessDefinition
    def make
        cursor do
            participant :qa_team
            participant :dev_team
            participant :customer_team
        end
    end
end

engine.launch(IssueTracking2)
#...

OpenWFEru 0.9.4 released

OpenWFEru 0.9.4 is out.

It features the CsvTable and CsvParticipant described in a previous post.

More documentation is available, there is a growing glossary and promising page about expressions. The participants page is still following.

The ‘when’ expression got implemented, you can use it to trigger the execution of a process segment later in time, when a certain condition is met.

The OpenWFE manual in Japanese

Sakaguchi Masahiko just translated the OpenWFE manual to Japanese.

That’s a huge effort, very impressive.

Sakaguchi-san is a Japanese open source developer. His interests lie mainly in scripting languages over the Java virtual machine. He just wrote an article on this subject for the magazine “Software Design” of January 2007.

He also wrote the openwfe-pnuts library.

His website / blog :

http://machine.homeunix.org/weblog/

The manual in Japanese :

http://machine.homeunix.org/my_stuff/openwfe_manual_ja/

Many thanks to Sakaguchi-san

m(_ _)m

ruby decision tables

update (2008/01/28) : I’ve packaged this ruby decision table system into its own “rufus-decision” gem.

---

It’s part of OpenWFEru 0.9.4 that will be released this week.

I’ve already blogged about decision tables. Now the implementation is available in Ruby as well.

Disclaimer : this decision table implementation, whether in Java or Ruby is not meant to replace a full rules system with features like forward and backward chaining, RETE implementations and the like. But it covers a lot of cases. Be pragmatic.

For example, in our workflow definition, there’s a point where we’ve got to decide if we should take our umbrella when going to work (please no comments).
In pseudo-code, take would look like :

    if weather == "rainy"
        take_umbrella = "yes"
    elsif weather == "cloudy"
        take_umbrella = "maybe"
    else
        take_umbrella = "no"
    end

As we don’t want to clutter our process definition with such cruft (or we simply don’t want to hardcode that into our source), we fire up our spreadsheet and write down the [business] rule.

That makes for a nice CSV file :

in:weather, in:month, out:take_umbrella?
,,
raining,,yes
sunny,,no
cloudy,june,yes
cloudy,may,yes
cloudy,,no

Leveraging OpenWFEru CSV tables, we can write such Ruby code :

require 'openwfe/util/csvtable'


table = OpenWFE::CsvTable.new("path/to/our/file.csv")


h = { "weather" => "cloudy" }
table.transform(h)

puts h["table_umbrella?"]
    #
    # will yield "no"

h = { "weather" => "cloudy", "month" => "june" }
table.transform(h)

puts h["table_umbrella?"]
    #
    # will yield "yes"

# ...

That feature will be available with OpenWFEru 0.9.4 (or immediately by checking out OpenWFEru). You can already have a look at the unit tests for it.

The documentation for CSV tables as [decision] participants to business processes will be available soon.

in the top ten

OpenWFEru, our open source ruby workflow engine made it in the top ten of the most active projects at RubyForge.

OpenWFE made it two times in Sourceforge’s most active, now it’s the Ruby era. The RubyForge is a nice place to develop in (thanks Tom).

There are still lots of things to do, like writing doc for CSV participants (aka decision tables), implementing persistence for workitem stores, thinking about ActiveRecord integration, port more of the original OpenWFE expressions, enhance the website, …

It’s great to code in Ruby…

OpenWFE 1.7.3pre0 released

Just released OpenWFE 1.7.3pre0.

It’s available via the sourceforge downloads.

Let the changelog speak for itself :

- 1.7.3pre0   svn3624
- [webclient] bug #1648292 : could not add field to ListAttribute whose
              name contained space. Fixed - s3622
- [applic]    bug #1651193 : intermittent exception due to unprotected
              SimpleDateFormat in Time utils. Fixed - s3621
- [engine]    todo #1634623 : ParticipantExpression : if the attribute
              'forgotten' is present sets the flag even to false - s3614
- [release]   todo #1634680 : switched from /bin/sh to /bin/bash - s3613
- [release]   bug #1632788 : sql scripts were not copied into release. Fixed
              - s3612
- [decision]  bug #1632789 : double table apply found by Gregory Joseph. Fixed
              - s3611
- [engine]    rfe #1610616 : implemented control.getFlowPosition() returning
              the expressions where a workflow instance is located.
- [-all-]     todo #1613738 : moved core non workflow things from openwfe-applic
              to openwfe-base - s3604
- [worklist]  bug #1605360 : REST getStoreNames() was broken. Fixed - s3569
- [worklist]  rfe #1601487 : added descriptions to REST listLaunchables() -
              s3564
- [rel]       bug #1600317 : launchitem 4 pointed to wrong flow URL. Fixed -
              s3562

The development of the Ruby engine slowed the development of the Java engine but did not stop it.

OpenWFEru 0.9.3 released

Just released OpenWFEru 0.9.3.

It features more participants, and an implementation of the cron expression (following the work on the scheduler).

The participant names can now be used as expressions (a feature not present in the classical Java OpenWFE) :

class AccountingThriceDefinition < OpenWFE::ProcessDefinition
    def make
        process_definition :name => "accounting_thrice", :revision => "0" do
            sequence do
                # sending thrice in a row, a workitem to the 'accounting' participant
                participant :ref => "accounting"
                participant "accounting"
                accounting
            end
        end
    end
end

This technique also works with XML process definitions (if the participant name doesn’t conflict with XML conventions). This should enhance the readability of some process definitions. In certain cases, being explicit doesn’t hurt though.

Otherwise, lots of small incremental improvements and changes have been made.

The next steps :

- implement persistence for the workitem store participants (yaml based)
- implement more of the OpenWFE expressions (like ‘when’, ‘do’, ‘redo’, ‘undo’, …)
- explore integration with Ruby on Rails

Feedback is welcome on the users mailing list