The relative importance of order

JBoss AS 7: Updated look&feel for CR1

2011-12-16T05:57:00.001-08:00

The JBoss 7 console gets a new look&feel with AS 7.1.CR1:

Before

After

iOS design pattern resources

2011-11-24T23:47:00.000-08:00

The guys from Cocoanetics have published a great collection of iOS related design pattern resources:

Have a look, be inspired.

JUDCon India, Call for Papers

2011-11-16T06:27:00.001-08:00

JUDCon 2012: India, January 24-25 in Bangalore, will be one of the premier technical JBoss developer events in India. JUDCons attract many of the best and brightest to present, and exchange ideas on JBoss technology.

Got something to say? Say it at JUDCon 2012: India.

The JUDCon call for papers is open now through November 26, and session tracks include:

JBoss AS7 Application Server
Rules, Workflow, SOA and EAI
OpenShift / Cloud
Cool Stuff (that we just can’t leave out)

Submit your papers here:

http://www.jboss.org/events/JUDCon/2012/india/cfp

Networked Society "on the brink"

2011-11-08T11:59:00.000-08:00

Nielsen: Eyetracking studies

2011-10-27T00:49:00.000-07:00

Interesting study about how users read on the web:Eyetracking Study of Web Readers

One Day Talk: Introduction to JBoss AS 7

2011-10-17T00:33:00.001-07:00

Here are my slides from this year one day talk in munich:

One daytalk hbraun_oct2011

View more presentations from hbraun

Turning my room into a kanban board

2011-10-06T08:02:00.001-07:00

Work needs to be organized. Here's my DIY, pseudo Kanban Board:

(This is actually the first post, where the name of this blog kind of makes sense...)

Managing JBoss7: Virtual Machine metrics

2011-10-04T05:41:00.000-07:00

We've added some simple VM views to current beta upstream. It allows you to monitor thread and heap usage of the VM the server uses:

There's room for improvements. Tell us what you think...

JBoss One Day Talk Munich, 13. Oktober

2011-09-30T00:10:00.000-07:00

OneDayTalk 2011 - the conference for JBoss and Java Enterprise technologies

As the successor of the successful JBoss OneDayTalk 2010 conference, the JBoss User Group Munich e.V. will organize a full day JBoss conference in Munich again. On 13.10.2011, everything will once again revolve around JBoss technologies and Java frameworks, with the focus on current topics such as Enterprise in the Cloud, Security, Operations, High Availability, Scalability, ESB,Web 2.0, Mobile, Clustering, and BPM / BPEL / BRM content.

As the successor of the successful JBoss OneDayTalk 2010 conference, the JBoss User Group Munich e.V. will organize a full day JBoss conference in Munich again.On 13.10.2011, everything will once again revolve around JBoss technologies and Java frameworks, with the focus on current topics such as Enterprise in the Cloud, Security, Operations, High Availability, Scalability, ESB, Web 2.0, Mobile, Clustering, and BPM / BPEL / BRM.

A large number of globally renowned speakers from Europe and the U.S. will come together on 13.10.2011 in the Konferenzzentrum München (Conference Center Munich) to present their practical knowledge, to report on project experiences and to provide you with the latest developments in software technology around JBoss, Java 6 and Java EE. The broad-based range of topics aimed not only at software developers and architects, but project managers and IT decision makers are also provided by leading JBoss project leads and core developers with valuable information.
The time between the presentations offers you many ways to get information from the exhibitors to have conversations and discussions with speakers and other participants, and not least to maintain your own network.

We are looking forward to see you on the conference - the registration is now open!

Developer notes: How does data binding and model conversions work in the AS 7 console?

2011-09-28T00:32:00.000-07:00

The JBoss AS 7 management layer works on a detyped, tree like mode structure to represent subsystem and server configuration options. The big benefit is that management clients don't depend on statically typed model, but instead rely on a fairly small API that's not subject to change. The model itself can easily be converted to and from JSON, which opens the management layer to variety of scripting environments and alternate management implementations.

As many of you know, the management web interface is implemented in GWT. The means we cross compile from Java to Javascript, but all development is done in Java. Many of the default GWT components like tables, trees and lists expect a strongly typed Java model, since this would be logical choice for most GWT implementations. For us, working on the management web interface this means we have to bridge the gap between the detyped model the application server uses and the strongly typed model the GWT components rely on.

In this post I am going to explain some of the building blocks we use within the management interface, to reduce the amount of boilerplate we have to provide converting between the two model representations.

The detyped model

A typical model representation we get from the AS management layer looks like this:


[domain@localhost:9999 /] /subsystem=datasources/data-source=ExampleDS:read-resource
{
    "outcome" => "success",
    "result" => {
        "connection-url" => "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1",
        "driver-name" => "h2",
        "enabled" => true,
        "jndi-name" => "java:jboss/datasources/ExampleDS",
        "jta" => true,
        "password" => "sa",      
        "use-ccm" => true,
        "user-name" => "sa",
    }
}

In this case we are looking at a data source.
In order create and modify datasource, the management client would need to send a detyped representation like the one above and will get a response of the same content type.

GWT entities

Entities in GWT are represented as Java interfaces with getter and setter methods (AutoBean API). The corresponding representation for the data source above, would look like this:


@Address("/subsystem=datasources/data-source={0}")
public interface DataSource {

    @Binding(detypedName = "jndi-name")
    String getJndiName();
    void setJndiName(String name);

    @Binding(detypedName = "user-name")
    String getUsername();
    void setUsername(String user);

    String getPassword();
    void setPassword(String password);

    [...]
}

Coverting between two models

Converting between the two model representation is the job of the EntityAdapter. An EntityAdapter works on the meta data declared on the entity class (@Address & @Binding annotations). The metadata itself is extracted during the compile time phase (deferred binding) .

The current meta data structure is divided into two distinct concepts: Entity addressing and the property binding. The address is required to perform operations on the detyped model ("/subsystem=datasource/data-source=ExampleDS:read-resource"). The property binding is used to get and set values within both models.

Let's take a look at an example:



// Create an EntityAdapter for a specific type
EntityAdapter adapter = new EntityAdapter(DataSource.class, metaData);

// Convert from entity to DMR representation
DataSource datasource = ...;
ModelNode operation = adapter.fromEntity(datasource);

// execute the operation (HTTP request) ...

First of all, we create an EntityAdapter for the DataSource.class type. This adapter allows us to convert an entity instance (DataSource datasource) into a ModelNode (detyped) representation. We can use this model to execute an operation against the AS management layer (HTTP Post).

Let's do it vice versa: Reading a detyped model and convert it into an entity.


// Create an EntityAdapter for a specific type
EntityAdapter adapter = new EntityAdapter(DataSource.class, metaData);

ModelNode detyped = ...; // HTTP response

// Convert form DMR to entity
DataSource datasource = adapter.fromDMR(detyped);

// Work on the entity ....

Addressing of resources

As you can see in the above example, the entity carries an @Address annotation. In order to read from or write the management layer you would need to know how to address a resource properly. For datasources this would be:


/subsystem=datasources/data-source=ExampleDS

There are many cases where we need an address. It makes sense to associate this information with the entity itself and use it as a template for subsequent requests. I.e an address template like "@Address("/subsystem=datasources/data-source={0}")"



AddressBinding address = metaData.getBeanMetaData(DataSource.class).getAddress();
ModelNode operation = address.asSubresource("ExampleDS");

// further specify the operation (OP, RECURSIVE,ETC)
operation.get(OP).set(READ_RESOURCE);

// execute the operation (HTTP request) ...

What's next?

We have seen how two specific problems are solved: Addressing of resources and converting between two model types. In the next part of this series, I am going to explain how the actual data binding (mapping to HTML forms) actually works.

Geoffrey West: The surprising math of cities and corporations

2011-09-17T11:16:00.000-07:00

Physicist Geoffrey West has found that simple, mathematical laws govern the properties of cities -- that wealth, crime rate, walking speed and many other aspects of a city can be deduced from a single number: the city's population. In this mind-bending talk from TEDGlobal he shows how it works and how similar laws hold for organisms and corporations.

Visual weight of primary and secondary action buttons

2011-07-25T05:42:00.000-07:00

Pretty interesting observation on why the irreversible, permanent action should become the secondary button:

http://uxmovement.com/buttons/the-visual-weight-of-primary-and-secondary-action-buttons/

Heap profiling on chrome

2011-07-06T00:17:00.001-07:00

Neat: http://code.google.com/chrome/devtools/docs/heap-profiling.html
It's becoming more important when you move to resource limited devices, such as pads and phones.

JBoss AS 7: Admin Guide, first draft

2011-06-22T05:31:00.000-07:00

I did finish the first draft of the AS7 "Admin Guide". It is intended for people who need to setup and configure the JBoss Application Server:

https://docs.jboss.org/author/display/AS7/Admin+Guide

Let me know what you think. There is plenty of room for improvements.Please send any comments and questions to the mailing list:

https://lists.jboss.org/mailman/listinfo/jboss-as7-dev

JBoss One Day Talk Munich

2011-06-21T01:51:00.000-07:00

Liebe JBoss OneDayTalk-Interessierte,

endlich ist es soweit und wir sind seit gestern mit dem Programm der JBoss OneDayTalk 2011 Konferenz online gegangen. Die Konferenz findet dieses Jahr am 13. Oktober 2011 in München statt. Und die Online-Registrierung ist jetzt geöffnet mit einer regulären Teilnahmegebühr von 89, - EUR. Sichern Sie sich jetzt bis zum 30.06.2011 ein Early Bird von 10%.

Es wird diesmal drei Tracks, 18 Vorträge und 20 Speakers geben. Das Programm und bereits bestätigten Talks finden Sie unter http://onedaytalk.org/index.php/program.

Unter den Speakerns sind unter anderem Adam Bien, Gavin King, Stefan Tilkov, Michael Plöd, Jan Wildeboer, Heiko Braun, Heiko Rupp, Werner Eberling, Volker Bergmann und Kris Verlaenen. Alle Speaker finden Sie unter http://onedaytalk.org/index.php/speakers.

Wir freuen uns über Ihre Teilnahme und für weitere Information besuchen Sie unsere Web Seite http://onedaytalk.org.

Viele Grüße vom JBUGM Team
http://www.jbug-munich.org

AS7 Console performance improvements

2011-06-14T06:33:00.000-07:00

I did take a look at the components that serve the console files again and removed some really sloppy parts and tweaked the HTTP cache behavior a little bit. With some really interesting results.

This is what the average page loading time looked like, when client did access the console for the first time:

This is what looks like after the improvements:

It get's even better, when a client does access the console subsequently:

How can it be explained?

Well the most notable improvement is probably the replacement of the sloppy IO parts. Hence the drastic page loading times from ~4sec to ~1sec. Furthermore the addition of an HTTP "Expires" header allows the browser to successfully cache the results, which drastically decreases the page loading size from ~750kb ~10kb. All tests have been run on a LAN connection.

Managing JBoss7: Console Beta9 released

2011-05-26T04:54:00.000-07:00

We just updated to 1.0.0.Beta9:
===================

- suport for standalone
- i18n
- deployments
- authentication

- datasources
- jms configurations
- messaging
- web subsystem

- server groups
- server configurations

- system properties
- jvm options
- socket bindings

The given functionality has small glitches here and there but most of it has been reported and is being worked on. In terms real tasks, this is still outstanding:

- transaction subsystem
- security
- webservices
- threads
- logging

But we expect this to be ready for 7.0.CR1.

Give it try & let us know what you think.
Tell us what works and what doesn't.

How do I access the console?
==================

http://localhost:9990/console

How do I enable authentication?
====================

Simply create a security realm configuration.
This needs to be done in "domain/configuration/host.xml" for domain mode:


<management>
       <security-realms>
           <security-realm name="ManagementRealm">
               <authentication>
                   <users>
                       <user username="admin">
                           <password>
                               password
                           </password>
                       </user>
                   </users>
               </authentication>
           </security-realm>
       </security-realms>
   </management>
   <management-interfaces>
       <native-interface interface="public" port="9999"/>
       <http-interface interface="public" 
            port="9990" security-realm="ManagementRealm"/>
   </management-interfaces>

Or "standalone/configuration/standalone.xml":


<management>
       <security-realms>
           <security-realm name="ManagementRealm">
               <authentication>
                   <users>
                       <user username="admin">
                           <password>password</password>
                       </user>
                   </users>
               </authentication>
           </security-realm>
       </security-realms>
   </management>

   <management-interfaces>
      <native-interface interface="default" port="9999"/>
      <http-interface interface="default" 
              port="9990" security-realm="ManagementRealm"/>
   </management-interfaces>

How do I switch between standalone and domain administration?
========================================

Just boot AS7 in either one of these modes and reload the console web application.

WebKit Remote Debugging

2011-05-11T02:14:00.000-07:00

Interesting, remotely connect the web inspector to a web kit instance:
http://www.webkit.org/blog/1620/webkit-remote-debugging/

Managing JBoss7: Messaging Provider Settings

2011-05-10T03:00:00.001-07:00

This should give you an idea how the HornetQ configuration is going to look like:

Messaging Provider

Queues & Topics

Managing JBoss7: Datasource Configurations

2011-05-06T07:18:00.000-07:00

We've begun working on datasource configurations within the web management interface. While it still requires some finishing touches, here's how regular and XA datasource configurations look like:

Managing JBoss7: Staging Applications

2011-04-14T04:22:00.000-07:00

Your colleagues are all stressed out, because the new build of your b2b app needs to be put on a staging server for your external partner to verify the recent API changes. How to get this setup and running without interfering with the existing production system? It's fairly simple. I'll show you ...

Step1: Create a dedicated server group for your staging servers

Step2: Prepare a staging server-configuration

A custom server-group separates our staging environment from the production servers.

... with a specific port offset

You need to remember this, in order to connect to the server instances later on.

Launch a server instance

So we can connect to it.

Deploy your application

In this case a simple web application.

... to the staging server-group

Domain deployments are always associated with server-groups.

Verify it has been deployed successfully

Grab a coffee and relax

Fairly simple, no?

Managing JBoss 7: UX updates

2011-04-07T02:09:00.000-07:00

The current JBoss 7 development stream contains an updated version of the console that will be shipped with Beta3. We've removed the clutter on the left hand side and do now provide a cleaner separation between navigation and functional elements. The LHS is now only used for navigational purposes and the any functional element (i.e. add, delete resources) has been moved to the toolstrips on the right hand side. Along with this change we've turned the stacked navigation sections (used to display only one at a time) into a more tree like structure, that shows all available options at one glance.

In our opinion this make it much easier to find relevant management options within the UI. Let us know what you think. Screenshots attached.

Server Configuration

Data Source Management

JBoss 7 Web Console: 1.0.0.Beta3

2011-03-30T04:38:00.001-07:00

Beta3 is the version that will be shipped with JBoss 7.0.0.Beta2 end of this week.

1.0.0.Beta3 Release Notes

Functional scope

Most of the work in this release has been done on the framework level, creating re-usable components that are needed to implement the remaining management use cases:

Form databinding & validation
Integration with the domain controller
General UI framework (MVP)

Functionally this release does focus on the outermost domain management use cases, that act as POC for the building blocks listed above.

Start/Stop server instances
Create server groups and server configurations
Configure server groups and configurations

The standalone server Web UI doesn't contain any reasonable functionality at this point.

The work on management use cases that relate to subsystems has not begun yet. There are merely two examples (Datasource and JMS) that act as a preview and should give you an idea where things are going.

Browser compatibility

This release has been tested on Chrome, Firefox and Safari. Internet Explorer has not been verified yet, but we don't expect it to work properly in releases before IE8.

Feedback

Your feedback is greatly appreciated. Tell us what you think about the current way the content is organized within the UI. Identify the top three things that don't make sense to you or that you couldn't find easily in the console. Send these issues to:

jboss-as7-dev@lists.jboss.org

In case you run into a bug, don't hesitate and file an issue here: (Don't forget to include your OS/Browser description)

https://issues.jboss.org/browse/JBAS (JBoss 7, Component "Web Console")

Firefox 4: App Tab

2011-03-23T13:02:00.000-07:00

Now that makes sense:

User Interfaces: Perceived and actual affordance

2011-03-23T03:08:00.000-07:00

"According to Norman, affordance refers to “the perceived and actual properties of a thing”, primarily the properties that determine how the thing could be operated. Note that perceived affordance is not the same as actual affordance. A facsimile of a chair made of papier-mache has a perceived affordance for sitting, but it doesn’t actually afford sitting: it collapses under your weight. Conversely, a fire hydrant has no perceived affordance for sitting, since it lacks a flat, human-width horizontal surface, but it actually does afford sitting, albeit uncomfortably.

The parts of a user interface should agree in perceived and actual affordances."

(Taken form MIT Courseware)

Nitro on IOS 4.3

2011-03-15T03:01:00.000-07:00

Why is Nitro disabled in UIWebView and full screen web apps on IOS 4.3?
Read more about it here

- More on this topic: http://www.theregister.co.uk/2011/03/15/apple_ios_throttles_web_apps_on_home_screen/

Contributing to the JBoss 7 Management Console

2011-03-11T04:23:00.001-08:00

You want to contribute to the management web interface for JBoss ? Then this should get you going.

Codebase

Everything is hosted at github, The best way is to create a fork of either one of the codebases listed below and work on that one.

- Authoritative master: https://github.com/jbossas/console
- Most recent: https://github.com/heiko-braun/as7-console

Prerequisites

The console it self is developed using the Google Web Toolkit. You would need to make yourself familiar with the basics before we et going. The GWT SDK will be installed as part of the maven build. No need to fetch it on it's own. If you plan to work with Eclipse, then you should consider the development tools for GWT that are provided by Google. But please don't ask how things are setup correctly in Eclipse. We baseline on maven and that's it.

Things you need to know

Widgets

We build on GWT 2.2 without any dependencies on external widget libraries. However these is a growing number of widgets (org.jboss.as.console.client.widgets) that should be reused. We aim for keeping the overall number of widgets to a minimum.

But if you need anything that doesn't exist, take a look at the SmartGWT showcase, tell us about it and we'll then consider implementing it.

MVP Pattern

But one of the cornerstones is the GWT Platform library, which nicely abstracts the MVP pattern. It act's as a blueprint for the console design. A good introduction can be found here. (This is a "must read")

AutoBeans

Internal model representations are build as AutoBean's. They align well with the default GWT API and have build-in serialization support. A general guideline: Any domain representation that's used within the console needs to be provided as an AutoBean abstraction. This means that beyond the integration layer (backend calls to the AS 7 domain) entities need to be adopted.

This is necessary to provide a baseline for the data binding used across widgets. Take a look at the form abstractions, then you'll know what I mean. The CellList and CellTable API's are another example.

Discussions

We are using the AS7 mailing lists and/or IRC for discussions of technical matters, improvements, proposed patches, etc:

- https://lists.jboss.org/mailman/listinfo/jboss-as7-dev

- irc.freenode.net#jboss-as7

Managing JBoss 7: Screenshots

2011-03-10T06:08:00.000-08:00

To add some meat to the discussion, here are some recent screenshots of the current web interface. It does use a very reduced look&feel at this stage, that allows us to focus on the tasks at hand, without getting distracted too much. In the next iteration we'll look into adding some proper styles, with the help of our design friends from jboss.org.

Server Groups

Deployments (associated with server group)

Server Configuration (on a host)

Server Instances (on a host)

Managing JBoss 7: A task oriented approach

2011-03-10T00:37:00.000-08:00

It's been several weeks now, since we started working on the management web interface for JBoss 7. Time to outline some of the general ideas and concepts the console is build on. If you are not familiar with domain management approach that has been introduced in 7.0, you should make yourself familiar with it before reading any further.

Conceptually the domain model consists of three different levels, that we tried to reflect within the user interface: Configuration profiles, server groups and host specific settings.

If you think of these levels as being layered atop of each other, then Profiles would be the bottom most configuration level that acts as a blueprint for the layers atop of it. Profiles consist of subsystem specific settings (i.e. JCA, TX, etc) and are referenced by Server Groups.

Server Groups on the other hand specify configuration properties for a set of Servers that run on different Hosts.

A Host is the top most and most detailed level. It runs Server Instances that belong to a particular Server Group.
While there are numerous ways to organize the information accessible through the web interface, we used a few simple questions to guide our decisions:

- "What are the primary tasks?"

- "At what frequency to these task occur?"

- "What's the impact on related configuration elements?"

The primary tasks already seem to be represented by the different levels described above: Changes to and requests of host specific information is something we expect to occur quiet regularly. This does cover use cases like starting server instances and requesting runtime state information (i.e. metrics).

Creation and modification of Server Groups will probably happen less often, except one specific use case, which is application deployment. Deployments are associated with server groups.

The least likely changes are going to happen on the profile level. I.e the modification of a thread pool size is something you probably wont do very often.

The outermost categorization looks as follows:

Now while this coarse grained organization nicely groups the primary tasks and allows you to focus on the goal you want to achieve, it doesn't give you any clues which configuration properties are inherited from lower levels. Some elements can be specified on a lower and be replaced on higher level (i.e. System Properties in profiles and server groups).

This problem has two sides: On the one hand you need to know where an inherited property comes from in order to change it, on the other hand need to know what impact a modification might have on higher levels (Think of a JVM property on the profile level that impacts all server groups).

This problem isn't solved yet. We are still working on visual distinction that allows you to clearly identify the source level of a configuration property and cross reference it accordingly. It might look like this:

Call for participation

There are plenty of other related topics that we can talk about, but that's it for today. If you want to participate, I would suggest you take a look at the following resources and let us know to what degree the suggested categorization makes sense.

- DomainManagementModelDesign

- jboss_7_0 schema

Stay tuned, we keep you posted.

"The future is bright and the present compelling ..."

2011-01-28T00:28:00.000-08:00

Dimitiris about the release of JBoss AS 6 and the work on AS 7:
http://jaxenter.com/jboss-as-6-0-0-final.1-34623.html

Export Mac OS Mail RSS URL's

2010-12-16T04:00:00.000-08:00

Neat and simple:

pubsub --client com.apple.mail list | cut -f3 | sed -ne '3,$p'

JBoss Developer Conference Berlin

2010-09-16T11:50:00.000-07:00

JUDCon Berlin - October 7-8, 2010
Boston was a smashing success. Now on to Berlin!

JUDCon, the JBoss User and Developer Conference, gives developers the unique opportunity to participate in deep dive sessions with JBoss Core Developers and other leaders the JBoss community. Code sessions, hackfests, beer and food... now that's a developer conference.

More here

GWT Compiler Options

2010-07-30T00:44:00.000-07:00

Joseph from the RHQ team has written a good article on how the different compiler options (num workers, Xmx, Xms) affect the overall compilation time: http://josephmarques.wordpress.com/2010/07/30/gwt-compilation-performance/

JBoss One Day Talk

2010-07-26T05:52:00.000-07:00

One Day, 14 sessions on two tracks. Get together with the experts and join us in Munich, 1. October 2010.
JBoss One Day Talk - From the community for the community.

From the web page:

"Die Konferenz für Java Frameworks & Enterprise Edition Technologien

Der JBoss OneDayTalk 2010 (organisiert vom JBUGM e.V.) ist eine ganztägige Konferenz, bei der sich alles um das Thema JBoss Technologien und Java Frameworks dreht. Experten aus den USA und Europa treffen am 01.10.2010 in München zusammen, um ihr Wissen, ihre Erfahrungen und ihre Ideen miteinander zu teilen und darüber zu diskutieren. JBoss Project Leads und Core Developers werden ebenso vertreten sein wie Mitglieder der JBoss Community, Softwarearchitekten und IT-Entscheider.

Erstklassige Sprecher und aktuelle Themen wie JAVA6, JAVA EE 6, Caching, Clustering, Cloud Computing,Wicket, BPM, BPMN, BPMS, BPEL, Rules, Web Services, Ruby-On-Rails, Auditing, Performance und Versioning persistenter Klassen garantieren eine erstklassige und spannende Veranstaltung. Dabei liegt der Fokus nicht nur auf der Theorie der vorgestellten Themen. Vielmehr wird es auch Erfolgsberichte aus "echten" Projekten geben, in denen sich die Technologien unter Alltagsbedingungen im Projektumfeld bewährt haben."

RHQ migrating to GWT

2010-06-18T01:13:00.000-07:00

Really nice. The RHQ team did a great job migrating parts of their UI to GWT. Take a look. It's impressive:
RHQ Screencast

Speaking at JBUG Munich (12.04)

2010-04-07T03:43:00.000-07:00

I'll speaking in Munich next monday (12.04):

In this presentation we'll see how to organize a nontrivial GWT application. We'll go through the lessons learned in a real world project and take a look the complete development lifecycle and best practices that go beyond what GWT has to offer out-of-the-box. This talk does focus on modularity of GWT applications and how to overcome the burdens of compile-time linking. We'll talk about client side patterns and server side implementation options and explore different approaches that allow for quick turn around times without sacrificing maintainability.

Details can be found here

JUDCon 2010

2010-03-31T11:08:00.000-07:00

JUDCon is an event by developers, for developers. Presentations will include a range of deep technical dives into JBoss Community projects and related technical topics of developer interest. The inaugural JUDCon will be a one day event packed with valuable sessions and will run into the early hours of the following day. For your convenience, JUDCon is the day before JBoss World and shares the same venue. In the future, look for stand-alone, multi-day events.

More information here

Riftsaw 2.0-Final ships the BPM Console

2010-03-31T11:03:00.000-07:00

Riftsaw 2.0-Final includes the BPM Console. Although pretty limited in functionality (merely a replacement for the ODE console) it will act as the foundation for future extensions. Read the full article here

Business Process Analytics using BPAF

2010-03-31T06:32:00.000-07:00

Over last 6 month I've been working on several components that will be assembled to a bigger business activity monitoring solution. I started off with a CEP based activity monitor (SAM) that allows for advanced correlation across heterogeneous event sources. After that I've spent some time integrating the BIRT reporting runtime with the BPM console, which allows you to run complex reports on process-related audit data. Only to realize that I've started on the wrong foot.

Process analytics bottom to top

I made a mistake to begin with the most complex components first, without realizing that the key to a successful BAM solution is underlying data model. Without a solid baseline the creation of report templates becomes a daunting task because the missing unification of audit data basically requires you to customize the report algorithms for any instrumented subsystem. Creating rules for the CEP component that fire when certain SLA's are breached doesn't get more simple either, when working on a heterogeneous event model.

I finally spend some time prototyping around an idea that has been in the wild for quiet some time: Baseline process-related audit data on BPAF: A WFMC standard that describes a data structure that enables the aggregation and correlation of audit data across multiple platforms.

In the following sections I would like to walk through a simple protoype, that already shows the benefits of this approach. It is really impressive how little code it requires to deliver a solution that already matches an important number of the use cases.

Data model, storage and retrieval

To begin with an implementation for storing and querying BPAF event data was needed. Fortunately JAXB and Hibernate made this a trivial task:


@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "eventDetails",
    "dataElement"
})
@XmlRootElement(name = "Event")
@Entity
@Table(name="BPAF_EVENT")
public class Event {

  @XmlElement(name = "EventDetails", required = true)
  protected Event.EventDetails eventDetails;

  @XmlElement(name = "DataElement")
  protected List dataElement;

  /**
   * A globally unique identifier for the individual event
   */
  @XmlAttribute(name = "EventID", required = true)  
  protected long eventID;

[...]

}

The current implementation allows two approaches for querying the BPAF data: Either leverage the default model and it's persistence implementation, or adopt a proprietary audit data structure to the BPAF model when needed. For later use case the API fo querying is split from the default data model:


/**
 * @author: Heiko Braun 
 * @date: Mar 10, 2010
 */
public interface BPAFDataSource
{
  /**
   * Get a list of distinct process definition ID's that are known to the system.
   * @return a collection of process definition ID's
   */
  List getProcessDefinitions();

  /**
   * Get a list of distinct process instance ID's that are known to the system.
   * @return a collection of process instance ID's
   */

  List getProcessInstances(String processDefinition);

  /**
   * Get a list of distinct activity definition ID's that are known to the system.
   * @return a collection of activity definition ID's
   */

  List getActivityDefinitions(String processInstance);

[...]
}

Now that we have components in place for storing and querying raw BPAF data, let's move on to a more interesting topic: How to make sense of it.

Turning data into information

The whole purpose of this exercise is to provide a way to gain insights about the execution characteristics of the processes that drive your business. While BPAF itself is a compact but still very expressive format (BPAF State Model) to store process-related audit data, it requires additional steps to turn it into consumable information that participants and decision makers can make sense of.

For the sake of this example we've added some algorithms that allow grouping and sorting of the underlying data, which will be used by the presentation layer.

Let's take a look at the prototype UI (yet another BPM Console plugin) and see how much information can already be derived without going through hoops and loops.

Presenting audit data to decision makers

The prototype UI demos a simple use case: "How did the processes execute in the past?" Although a simple question, it already implies a lot of fine grained functionality a user might expect:

Selecting a relevant process
Restricting the query to a certain time period
Scrolling through business related events that occurred over a period of time
Zooming in and out on a time scale (hourly, daily, weekly, etc)

Concepts represented by the prototype UI

For the sake of simplicity the current implementation (at the time of this writing) is limited in functionality. Nevertheless I would like to walk you through the current features and explain some of the key concepts.

To begin with a user selects the Process Defintion and the relevant time period:

The time period offers a set of commonly used intervals, like "Last Week", "Last Quarter" or "Last 24 Hours".

The BPAF data is loaded and grouped according to the time period and presented in an interactive chart:

The charts allow you to zoom in on the time scale (i.e. "1 day, 5 day, max") and scroll through the event data on each level.
(Shout-Outs to the chronoscope project)

You can comment on the information and create markers on business relevant points that either require clarification or otherwise mark notable changes in the execution of a process:

Conclusion and next steps

As you see, this simple prototype already covers important features that you would expect from such an implementation.
And we didn't yet touch sophisticated topics like comparison of process executions or creation of key performance indicators that trigger notifications (do the markers ring a bell?).

In the next few month you can expect this approach to be married to SAM, our CEP based BAM component that allows correlation and execution on process activities close to real time.

Stay tuned, now that we have a common baseline for representing and querying process-related audit data we'll look into more advanced topics.

Good introduction to Akka

2010-03-13T05:06:00.000-08:00

Jonas Boner has provided a pretty good introduction to Akka. If concurrency, fault-tolerance and scalability matter to you then this is a must read.

Enjoy.

BPM Console 2.0.1 released

2010-03-04T04:53:00.001-08:00

I am glad to announce the BPM Console 2.0.1. Although it doesn't include many new functional enhancements, architecturally it's still a major step forward. Let's take a look at the most prominent changes first:

Workspace API consolidation

This is probably one of the most important steps. Something that we had on the roadmap for quiet some time. Before 2.0.x the BPM build on it's own workspace API, which is fully merged with errai-workspaces. Not only does this consolidate the web tooling efforts within JBoss, but it also allows building of true federated toolsets using the errai bus and workspaces modules as a foundation.

This allows us to easily integrate tools from other JBoss projects into a custom workspace build. I.e. something that we are currently thinking about is integrating the Apache Juddi web console as part of the Riftsaw console offering.

Improved performance and development tools

We've been running the console on GWT 1.5.3 for quiet some time but now it leverages GWT 2.0. Probably the most important changes for the BPM console are support for code splitting and declarative UI's.

JBoss system theme

We started working on a custom theme, that should apply to JBoss web tooling in general. It's still in the early stages, but already included in the recent release. We are aiming for a design that's clean, concise and doesn't get in your way:

Role based authorization

Since we migrated to errai-workspaces the BPM console now has support for role based authorization. This means you can easily restrict access to certain tools (i.e. admin vs. user) or use this mechanism to create customized profiles according to a users role (i.e. sales vs. marketing)


@LoadTool(name = "Deployments", group = "Runtime")
@RequireRoles({"administrator"})
public class DeploymentModule implements WidgetProvider
{
  [...]
}

History and perma links

One feature that has been requested a lot, was support for linking to tools from an external application. I.e. when a email notification is send for an outstanding task. This is now built into errai-workspaces. The same mechanism that allows you to use the default browser history navigation, can now be used to reference tools from external applications.

Report parameter preferences

The console supports parametrized report templates since version 1.3. What has been added is the ability to store report parameters for each template as part of the console preferences. Imagine a report that requires you to enter a certain time period for rendering. This data is now store within as part of console preferences, so can easily switch between report templates without having to provide that data over and over again.

Roadmap

In the next few weeks we'll focus on the toolset for the Riftsaw BPEL Engine. Areas that need improvement are activity monitoring tools and tools for maintaining WS endpoint references, like the UDDI browser.

Contributions

As I said earlier, 2.0.x was an important step regarding maintainability and API consolidation. We now have everything in place for you to get your hands on the errai-workspaces module and start developing plugins for the BPM console in particular or the JBoss SOA platform in general. In case you are interested, don't hesitate to get in touch with us:

IRC: errai@irc.freenode.net
Mail: http://jboss.org/errai/MailingLists.html

Bela Ban at JBUG Munich, 08.03.2010

2010-03-01T10:39:00.000-08:00

Bela talks about ReplCache:

Memory is the new disk, disk is the new tape

ReplCache is a tool to store data in a cluster. It is essentially a hashmap spanning multiple hosts in a cluster.

There are put(), get() and remove() methods which distribute data over the cluster.

The unique feature of ReplCache is that it allows to define a replication count per element, e.g. how many times should an element be stored (on different nodes) for redundancy. When the cluster changes, e.g. due tonew nodes joining or nodes crashing, elements are automatically rebalanced to satisfy replication counts.

Given enough nodes and the assumption that not all nodes ever crash at the exact same time, we can get rid of our database, and use the aggregated memory as our large virtual memory-based database!

(For the paranoid folks, we can still stream the data away to disk/DB).

We will also discuss the architectural approach for applications leveraging ReplCache and which for which kind of application this architecture will be suitable.

Details can be found here

Talking at JUG Zurich @ 2.3.2010

2010-02-16T07:20:00.000-08:00

I'll be talking about GWT and project Errai in particular at the Java User Group Zurich at the 2.3.2010:

Patterns and Best Practices for building large GWT applications

In this presentation weʼll see how to organize a nontrivial GWT application. Weʼll go through the lessons learned in a real world project and take a look the complete development lifecycle and best practices that go beyond what GWT has to offer out-of-the- box. This talk does focus on modularity of GWT applications and how to overcome the burdens of compile-time linking. Weʼll talk about client side patterns and server side implementation options and explore different approaches that allow for quick turn around times without sacrificing maintainability.

As part of this talk we'll look at project Errai (http://jboss.org/errai) and
see how it can help to achieve these tasks.

In case you are around, make sure to show up.

BPM Console 1.2 released

2009-11-03T02:31:00.000-08:00

Release Notes - BPM Console - Version BPM Console 1.2

Bug

[BPMC-15] - Principal not correctly resolved

[BPMC-20] - Parse error on process instance with two active nodes

[BPMC-25] - XMLProxy chokes upon cookie initialization

[BPMC-24] - 'rootToken' is optional in the ProcessInstanceRef

Feature Request

[BPMC-14] - Add support for custom reports

[BPMC-17] - Add paging to processdefinitions, processinstances, tasks, ... views

[BPMC-21] - CSS for task forms

[BPMC-22] - Auto-resize task form windows

[BPMC-26] - Provide preferences panel

[BPMC-27] - Initialize report server when server module is loaded

Talk on GWT & Errai @ JUG Stuttgart

2009-10-20T05:48:00.001-07:00

GWT Jug Stuttgart

View more documents from hbraun.

Drools 5.1 M1 ships the BPM console

2009-10-07T00:22:00.000-07:00

Drools 5.1 M1 includes the recent BPM console. Take a look, give it a ride: http://blog.athico.com/2009/10/drools-51-m1-release-notes.html

Activity Monitoring, Part 1: A twitter example

2009-09-10T06:45:00.000-07:00

SAM has been around for quiet some time, but still didn’t get much traction. On the one hand I was involved with other projects and on the other SAM did lack good examples that reveal the underlying concepts and put them into context.
In the past few days I’ve put together an activity monitoring demo that will be used to explain the core concepts and give you an idea how SAM can be used to monitor activities of a particular domain.

Event streams

First of all, a good example needs constant event feeds. I was thinking about monitoring TCP packages on my box, but then came up with much more comprehensive example: Twitter feeds. Twitter has such a high volume of messages that it’s easy to derive event streams from it. In order for correlation to make sense we need events that share some kind of context. Using the twitter search API we can query messages that contain particular keywords, which is just enough contextual information for this example to make sense. Because I was tired of the king of pop, I decided on another high volume discussion, in this case iran.

You may ask: “Why event streams to begin with?” Because SAM is intended to monitor activities in a system close to real time. System activity is expressed a number of events that happen in no particular order but constantly over time. Event’s don’t even need to share the same properties, even though in our example they do.
And last but not least: It’s no fun to monitor a system without activity. You’d just get blank graphs and empty tables, which is hard to explain to the audience.

Correlation

Events come in all kinds of flavors. Most likely events share common properties if they derive from the same domain, i.e the twitter message cloud. When instrumenting a target domain you create event representations and push them to SAM using a specific stream input. A stream input is bound to a transport layer (i.e. JMS) and has a set of processing rules associated with it. These rules are used to monitor and act upon event streams if certain conditions kick in:

rule "all iran tweets"
when
    $tweets: List() from accumulate(
      $t : Tweet(id>0) over window:time(15s) from entry-point "iran tweets",
      collectList( $t )
   )
then      
   SAM.getListener("iran results").update($tweets); 
end

In this example a simple rule is associated with the event stream input “iran tweets” that collects messages over a 15sec time window and pushes them to a stream output “iran results”.

While stream inputs collect events, stream outputs are used to forward events,
i.e. for notifying SLA watchdogs. The number of processing steps between input and output is not limited. You may use rules that trigger other rules. I.e. first filter certain events and then correlate them:

But for the sake of simplicity we simply collect events over time and push them to the monitoring UI. We could add more complex processing rules, but that would extend the scope of this blog post and will be explained in Part 2 of this series. But for those of you who cannot wait, I suggest to take a look at Drools Fusion, the CEP engine that drives the complex correlation capabilities within SAM.

Monitoring

The whole purpose of SAM is monitoring and management of a system in place. SAM has a close relation to BPM console, as it will be used to realize the BAM capabilities (Business Activity Monitoring) for JBoss BPM projects. For this reason I’ve chosen to implement the monitoring UI right atop of the BPM console framework. The user interface you see in the next sections is actually an editor component that can be plugged into the BPM console.

But before we dive into the details, we need explain how SAM interfaces with a monitoring console.

The monitoring UI and SAM are decoupled through the use of current value tables (CVT). A CVT holds the correlation results at a particular point in time. Any processing result that is forwarded to an event stream output will update a specific CVT that is associated that output. The monitoring UI doesn’t access the stream output directly, but instead reads the data from a CVT:

So, whats happening in our twitter example? Every 15 sec we collect the events from our stream input and simply forward to a stream output, that in our case is writing to a current value table. The monitoring UI runs in a another thread and uses a different update interval. It assembles a graphical representation and displays it to the user. In this case a line chart that depicts that number of messages at given point in time:

Et voila! We’ve reached our first milestone: Monitoring twitter participation on a certain topic close to real-time.

Analysis

As the name suggests, a current value table only holds most recent data. In our example it means the last sample point on the x-axis of the chart above. Here’s the corresponding value table:

In this case four people have been tweeting about “iran” at that given point. But what if we want to go back in time? I.e. inspecting a previous peak or any other kind of derivation? Fortunately our CVT implementation doesn’t simply purge all records when an update occurs, but instead “swaps” all data to a Handler that will maintain a CVT’s history. It stores all snapshots so they can be retrieved later on.

Second milestone: We are not restricted to the most recent data, but can also go back in time and compare current and past event streams by simply navigating through the chart:

Drill down

That leaves us with one remaining question. The event properties available are pretty limited. Why is that? And how can we get to the details?

In order to answer these questions we need to step back a little. SAM tries to provide event stream analysis close to real time. That means we aim for minimum footprint whenever possible. Event representations travel back and forth through the whole monitoring infrastructure, beginning with the target domain being monitoring, then entering the event processor itself and finally being represented visually in a monitoring UI. It’s important to restrict the payload without sacrificing the analysis possibilities. The solution is simple: SAM works with references to both the target domain and the event entity. Basically everything that is required are an event context (i.e. twitter user name), a timestamp and a reference id (i.e. message id). Other properties that go beyond that depend on the correlation rules you want to apply. The challenge when creating a monitoring solution is finding the right balance between target domain instrumentation (initial event representation) and correlation capabilities.

If we stick to our example, both message ID and username are sufficient to drill down later on. We can always go back to twitter and retrieve the message contents for a particular message ID. It leverages one of the fundamental ideas behind SAM CVT implementation: On-demand content retrieval:

Putting it all together

Let us quickly recapture what has been explained here.
We capture events of a target domain and push them to SAM through event stream inputs. Each input is associated with a set of processing rules that monitor the event stream and kick in on certain conditions. When rules kick in we can forward events to stream outputs or further feed them into the processor.

One of the use cases for stream outputs are monitoring tools that display the information to a user. Users watch for exceptional situations and need to know what’s causing them. This also implies access to events that did happn in the past.

Thorough analysis requires you to drill down to the event details and the source of information. Which is not necessary for all events, but only those of interest hence the need for on-demand content retrieval.

Comments? Thoughts? Please let us know at the Overlord forums.

In the meantime enjoy the screencast of the twitter monitoring demo in action.

Fred Sauer speaks at JBoss World

2009-09-04T00:22:00.000-07:00

Sildes can be found here...

BPM Console 1.1.2 released

2009-08-31T05:54:00.000-07:00

BPM Conosle 1.1.2 carries minor enhancements, probably the most notable change is the switch from HTTP Basic Auth to form based authentication and session management (BPMC-12). Here's the complete changelog:

Release Notes - BPM Console - Version BPM Console 1.1

[BPMC-7] - url is wrong in the resources page for jbpm profile
[BPMC-1] - Make tasks the default editor
[BPMC-2] - Move settings to the bottom
[BPMC-3] - Split rendering directives and process variables in form processor
[BPMC-5] - Tomcat Lite doesn't pickup profile changes
[BPMC-9] - Form processing requires access to principal doing the call
[BPMC-10] - Pick JAAS domain for server module from build profile
[BPMC-8] - Set the correct log for RESTEasy in JBoss As.
[BPMC-12] - Switch to form based authentication and session management
[BPMC-13] - Remove TX demarcation inPluginMgr

BPM Console screencasts

2009-08-24T06:47:00.000-07:00

Several new screencast have popped up recently that show the BPM console in Action.

- Joram shows how to customize the reporting.
- Kris did an excellent overview of the console as a whole, including task forms.

Alex McGuire on Using Scala in a Large-Scale Project

2009-07-23T00:22:00.000-07:00

Alex McGuire, a developer with Électricité de France, describes how his team has been gradually migrating to Scala in a 300,000-line mission-critical production application. More ...

James Strachan on Scala

2009-07-07T11:49:00.000-07:00

If you are interested in Scala, then I'd recommend James blogpost on Scala. He did collect a lot of resources to whet your appetite.

Integrating App Engine with EC2

2009-06-30T02:27:00.000-07:00

A usual morning: Grab a coffee, check your emails and browse the latest rss feed updates. This time stumbled across an interesting session, given at google i/o: "App Engine Nitty-Gritty: Scalability, Fault Tolerance, and Integrating Amazon EC2"

Client-side data storage: JavaScript database support

2009-06-25T14:34:00.000-07:00

I remember the days when Javascript was considered a severe security vulnerability. Now we get client side javascript database support. Safari already implements it. Wicked!

Drools Flow adopts BPM Console

2009-06-25T03:06:00.000-07:00

Kris Verlaenen, the Drools Flow lead, has successfully adopted the BPM Console for Drools.
This means you can now manage Drools Flow processes the same way you do in jBPM4.

That's great news. It shows that the initial design, decoupling the console from the engine has proven to be successful.

Read more...

"Clothes make a man": Moving to gwt-mosaic 0.1.10

2009-05-18T04:26:00.001-07:00

Since jBPM 4.0.0.CR1

Today I've tested the new mosaic styles on the BPM console.
Thanks to George for back porting the
Aegean theme and the layout manager improvements to the mosaic build for GWT 1.5.3:

BPM Console, Task UI Demo

2009-05-14T01:50:00.000-07:00

I've created a quick demo of the new Task UI feature, embedded in the console. Enjoy!

BPM Console, Task UI Demo from Heiko Braun on Vimeo.

(Best viewed full screen with scaling turned off)

Questions? Leave a comment in the forum.

BPM console: springtime cleaning

2009-04-23T01:43:00.000-07:00

Since 4.0.0.Beta2

The BPM console is approaching Beta3 and it was about time to tidy up. We'd been running on gwt-ext from the beginning, because it was easy to get started with the project. But due to some license changes in the gwt-ext project, we'd been forced to abandon that approach and chose gwt-mosaic as it's successor. Mosaic works like charm and will eventually evolve as the default library for any JBoss GWT console.

Plugin-API and workspace composition
We are still looking into unification that allows composition of management interfaces across JBoss project within a single console. The BPM console already follows that approach, which has been explained in a previous blog post. Besides some minor refactorings in the plugin-api, the concept did basically remain the same: A workspace is assembled at build-time. Editors (workspace plugins) are retrieved from the classpath (maven dependencies) and configured through a workspace configuration:

workspace-default.cfg


org.jboss.bpm.console.client.process.ProcessEditor
org.jboss.bpm.console.client.task.TaskEditor

# not yet implemented in jBPM4
#org.jboss.bpm.console.client.report.ReportEditor

Proper MVC design
If you got the chance to look into the previous codebase, you'd probably realized that the model and view components have been tightly intermingled. It was a result of the early UI prototypes that simply survived across releases. But with migration to mosaic, we decided to clean it up was well. The current implementation uses mvc4g, a GWT ready implementation of the HMVC pattern. As a result the plugin-api does leverage that pattern by default:

If you now look at the sources, you'll find a clean and easy to understand separation of editors, actions and views:

Improved error handling
One of the major complaints we received about previous console versions, was the fact that, sometimes it got stuck without any indication of what has been going wrong. With the latest refactorings, any HTTP request handling has been delegated to the core GWT RequestBuilder classes. This gives us more fine grained control, including request timeouts and http status codes as well as standardized error reporting.

New look and feel
Mosaic is more close to the actual GWT sources and hence less fancy. But the actual Widgets are less error prone and do render faster then gwt-ext:

Stay tuned. Now that we got the codebase in good shape for this summer, we'll proceed with functional enhancements: Task forms and reporting.

Join the discussion in the console dev forum.

JBoss at Google Summer of Code

2009-03-31T02:01:00.001-07:00

JBoss is mentoring projects at this year Google Summer of Code again. If you interested in working on jBPM or JBoss projects in general then please checkout the list of available projects.

jBPM offers a list of projects that will be mentored by Tom and me. If you are interested in one of those get in touch with us.

jBPM Task Management: A look at the participation model

2009-03-30T06:41:00.000-07:00

Since 4.0.0.Beta1

The revisited task management model in jBPM introduces a new concept: task participation. The participation model describes identities (user or groups) and the type of involvement in the actual completion of task:

Example 1: User and business administrator participation
A common use case where this model fit's quiet nicely is the distinction between a user that actually performs the task and a business administrator monitoring progress. Depending on the participation type some principals will actually do the work, while others make sure tasks are executed within given constraints (i.e. priority, duedate, etc).

Example 2: Task stakeholders with different participation types
Another example could be stakeholders monitoring the actual outcome of task, or delegation between different participants that co-operate on a task. In this case a "initiator" of task, a "candidate" performing the work and the "final recepient" might be different participation types.

The TaskService API already reflects those changes:



org.jbpm.TaskService 
{
   [...]
/**
   * retrieves a list of tasks for a user
   * and a particular {@link org.jbpm.task.Participation} type
   *
   * @see org.jbpm.TaskQuery
   */
  List findTasksByParticipation(String participation, UserRef user);

  /**
   * retrieves a list of tasks for a group
   * and a particular {@link org.jbpm.task.Participation} type
   *
   * @see org.jbpm.TaskQuery 
   */
  List findTasksByParticipation(String participation, GroupRef... groups);
}

Currently we ship some default participation types, out of which only type 'candidate' is supported, but you can expect this to be extended in the near future.


org.jbpm.task.Participation
{
   [...]

  String CANDIDATE = "candidate";

  IdentityRef getIdentityRef();
  
  /** see constants for default participations */
  String getType();
}

Stay tuned.

Task management extensions: Human interaction management

2009-03-20T05:50:00.000-07:00

a) Application: Some process being executed that hits a task activity

b) Task Mgr: The current jBPM4 base model for managing tasks. It includes assignments, variables, etc.

c) Notification Mgr: Decouples the notification features. I.e. email, ical,etc. The idea is borrowed from the latest code contribution.
How and if the task management does notifications will be pluggable. We will probably provide a smtp notification mechanism as the default.

d) Form Mgr: Interfacing the outside world. Formost use would be HTML forms of some kind, but can be a WS interface as well. The Form Mgr relies on the variables and resources associated with a process.

RFC: Process deployment use cases

2009-03-10T08:25:00.000-07:00

This is a request for comments.

Since 4.0.0.Beta1

What deployment use cases do we want to cover?
What constraints should apply for each use case?

The matrix below shows the constraints for the deployment policies that are currently implemented:

Explanation:

There is currently four properties that are taken into consideration when processes get deployed:
the process name and version (part of jpdl.xml), the artifact name (i.e OrderProcess.par) and the artifact timestamp.
Process name, version and artifact name are the main properties that distinguish process deplyoments, the timestamp basically just acts as a fallback when no version is given and leads a version auto-increment.

Possible combinations of those properties lead to matrix above.

Work on the jBPM4 deployer started

2009-03-10T08:24:00.001-07:00

Jbpm4 Deployer

View more presentations from hbraun.