I'll be doing a jBPM talk and demo on the upcoming Drools & jBPM event in London. Register now for this free event, limited spaces !


Join Red Hat on Thursday 8th March, London, to learn how Business Rules Management Systems (BRMS) and Business Process Management Systems (BPMS) can help businesses leverage technology more effectively and increase productivity. Enterprise Open Source is leading the way with powerful capabilities and a industry-leading innovation.

In this half-day technical seminar join Red Hat to learn about:

• Understand the capabilities of JBoss BRMS and BPMS
• See how Open Source can drive innovation in areas such as CEP and Planning
• See examples of production deployments
• Understand the Technology roadmap

The technical sessions will be lead by Mark Proctor, Red Hat's Worldwide Technical Lead for BRMS & BPMS.

Who Should Attend
Architects and Developers who want to understand what is possible with Open Source BRMS and BPMS.


Register Now
We look forward to seeing you on Thursday 8th March

JBoss Red Hat Team UK




Register Now




When and Where
Thursday 8th March
London






Agenda





09:00
Registration, tea and coffee
09:30
Introduction/ Welcome
09:45
Rules, Events & Processes: the Open Source way
Mark Proctor - Worldwide Technical Lead for BRMS & BPMS, Red Hat
10:45
Decision Tables
Michael Anstis, JBoss Core Developer, Red Hat
11:15
Tea/Coffee Break
11:30
BPMN2 and jBPM5
Kris Verlaenen, JBoss Core Developer, Red Hat
12:15
Solving Planning Problems
Geoffrey de Smet, JBoss Core Developer, Red Hat
12:45
Case Studies
13:00
Lunch and Networking

Register now to join us for the free Drools & jBPM London 2012 event, hurry limited spaces :)
http://redhat-mail.com/t/XRU-OE4J-824IMOYW1D/cr.aspx


When Thursday 8th March
Where Ave Maria Lane, London, London EC4M 7DD (near St Paul's Tube)


Agenda 09:00 Registration, tea and coffee 09:30 Introduction/ Welcome 09:45 Rules, Events & Processes: the Open Source way
Mark Proctor - Worldwide Technical Lead for BRMS & BPMS, Red Hat 10:45 Decision Tables
Michael Anstis, JBoss Core Developer, Red Hat 11:15 Tea/Coffee Break 11:30 BPMN2 and jBPM5
Kris Verlaenen, JBoss Core Developer, Red Hat 12:15 Solving Planning Problems
Geoffrey de Smet, JBoss Core Developer, Red Hat 12:45 Case Studies 13:00 Lunch and Networking

Register now to join us for the free Drools & jBPM London 2012 event, hurry limited spaces :)
http://redhat-mail.com/t/XRU-OE4J-824IMOYW1D/cr.aspx


When Thursday 8th March
Where Stationers Hall, London


Agenda 09:00 Registration, tea and coffee 09:30 Introduction/ Welcome 09:45 Rules, Events & Processes: the Open Source way
Mark Proctor - Worldwide Technical Lead for BRMS & BPMS, Red Hat 10:45 Decision Tables
Michael Anstis, JBoss Core Developer, Red Hat 11:15 Tea/Coffee Break 11:30 BPMN2 and jBPM5
Kris Verlaenen, JBoss Core Developer, Red Hat 12:15 Solving Planning Problems
Geoffrey de Smet, JBoss Core Developer, Red Hat 12:45 Case Studies 13:00 Lunch and Networking

Another new feature in Errai 2.0 is the addition of WebSockets support for the ErraiBus. It provides a transparent COMET-to-WebSockets session upgrade mechanism within the bus itself. This means, that no changes are required to your existing Errai code to take advantage of WebSockets. When enabled, all bus traffic (CDI events, RPC, Bus Messages) will all be routed over the WebSocket channel.

WebSocket support is still not very up-to-snuff in the world of Java Servlet containers and even web browsers. Therefore, our existing WebSocket support is technically considered experimental .

But when it comes to the open source community, there's never any shortage of people willing to play. And we'd love it for you to give the feature a spin.

The WebSocket server is a built-in feature of ErraiBus 2.0. Therefore all you really need to do, metaphorically speaking, is flip the switch to turn it on. You do this by adding the following line to your ErraiService.properties file:

errai.bus.enable_web_socket_server=true

Now startup your app, and use a compatible browser (like Chrome or Firefox) and connect to your app. Then, open up your JavaScript console and check to see that it actually worked:



Hey, check it out! Errai opened a web socket. You can actually see more information about the connection state itself by executing the JavaScript function errai_status() from the console:



You may notice something curious here, however: the WebSocket server is running on port 8085 not port 8080 with the rest of the appserver. This is simply because currently, due to lack of standardized support in Java Servlet containers (although there is an effort afoot to remedy this), we currently run the WebSocket server as a sideband server.

This, of course, is not ideal and it's something that we at JBoss are working to address in an internal cross-project effort. I hope to be making some interesting announcements about that over the next year.

But that's not the end of the world, of course. There are front-end proxy solutions which can be used to remedy this problem and munge the servicing of the WebSocket onto the same public-facing port -- the facilities of which are usually good practice for any application server environment in any case.

Anyways, I'd love to hear back from the community on this.

Mike, out.

I have released Tattletale 1.2.0.Beta2 to the community for testing.

Full release notes are here.

Bug fixes

The release mainly contains bug fixes for the issues found by the community. Over 1200 downloads of Beta1 is quite impressive, so keep the feedback coming !

This release should work better on that other OS too...

JBoss Application Server 7

The JBoss Application Server 7 plugin has been updated to the JBoss Application Server 7.1.0.Final release, so that should get your applications up and running on that release faster :)

Community

There are still ideas that we are working on, so if you are interested in helping out with Tattletale development feel free to drop by our forums and fork the code from GitHub.

For Those About to Rock, We Salute you !

[WebSite] [Download] [Documentation] [Forum] [JIRA]

I have released Tattletale 1.2.0.Beta2 to the community for testing.

Full release notes are here.

Bug fixes

The release mainly contains bug fixes for the issues found by the community. Over 1200 downloads of Beta1 is quite impressive, so keep the feedback coming !

This release should work better on that other OS too...

JBoss Application Server 7

The JBoss Application Server 7 plugin has been updated to the JBoss Application Server 7.1.0.Final release, so that should get your applications up and running on that release faster :)

Community

There are still ideas that we are working on, so if you are interested in helping out with Tattletale development feel free to drop by our forums and fork the code from GitHub.

For Those About to Rock, We Salute you !

[WebSite] [Download] [Documentation] [Forum] [JIRA]

Last week marked one of the largest releases in JBoss history: JBoss AS 7.1.0.Final "Thunder" is finally out. You can read about the shiny features and achievements that come with the release in any of the multiple posts that have been published these days [1][2][3][4], AS 7.1.0.Final really deserves being tried, you'll love it ;-)
Here I'd just like to stress the relevance of having achieved JavaEE 6 Full Profile compliance. JBoss AS 7.1.0 satisfies all JavaEE compatibility requirements, allowing for real portability of nowadays enterprise Java applications. Regardless of that, AS 7.1.0.Final is still faster, smaller and more manageable than any previous JBoss AS release.
From a webservice point of view, officially achieving JavaEE Full Profile compatibility is the result of more then an year of hard working with TCKs (even before AS 7 actual development start!), given the ws related test groups are among the biggest ones in there.Finally, I believe this is a great result / milestone also for the Apache CXF project, as JBossWS 4.0.1 installed on JBoss AS 7.1.0 relies on Apache CXF 2.4.6 for serving any JAX-WS functionality.
Time to try JBoss AS 7.1 ! http://www.jboss.org/jbossas/downloads

With 7 votes already, remote event handling in Hot Rod is one of the most demanded features in Infinispan, and we've just started designing it. You can find out more about the design in this article and I've also started a Infinispan Development mailing list discussion in order to open a debate on this article.

Remember that remote event handling is the key piece that allows near-cache like patterns to be built in Infinispan and we know for a fact that this is one of the most demanded Infinispan patterns. So, if you have an interest in near caches, please provide any feedback you might have on the kind of event subscriptions and notifications you're interested.

To provide feedback, either comment on the linked article , or join Infinispan's Development mailing list and reply to the mail thread.

Cheers,
Galder

We're planning a new webinar on the latest features of jBPM 5 and a preview of some of the upcoming features this week. Register now !

jBPM 5: Redefined, Simplified, and the Open Source BPM

jBPM is one of the most popular open source BPM/workflow solutions on the market. Over the years it has been widely adopted by many enterprises due to its many unique characteristics, such as:

• a lightweight footprint
• an embeddable engine
• its ease of use

jBPM 5 has taken these unique characteristics to the next level by adopting the popular BPMN 2 standard. BPMN 2 is not only the choice of standard for modeling, but also the choice for native execution.

jBPM 5 is a redefined BPM implementation that is further simplified for ease of use and offers flexibility in meeting wider enterprise needs. This webinar will discuss many of the key functionalities and future direction of jBPM 5, including:

• BPMN 2 based process modeling using rich web based designer and Eclipse editor
• Human interaction based on the WS-HT standard
• Process monitoring and debugging
• Support plan through JBoss’ enterprise product

You will also learn how to build adaptive business processes by leveraging the combined power of business rules, business events, and processes.

Speakers:

Prakash Aradhya, Sr. Product Manager, Red Hat
Prakash Aradhya is responsible for driving the product strategy and roadmap for JBoss Enterprise BRMS and BPM products. He has over 15 years of experience in product development and product management in the middleware software industry. Prior to his focus on the BRMS and BPM products, Prakash was responsible for JBoss Developer Platform product management which included JBoss Developer Studio. Prior to joining Red Hat, Prakash worked at Sun Microsystems (now part of Oracle) as SOA Product Manager for the Sun Java CAPS product.

Kris Verlaenen, jBPM 5 Project Lead
Kris Verlaenen leads the jBPM 5 effort and is also one of the core developers of the Drools project, to which he started contributing in 2006. After finishing his PhD in Computer Science in 2008, he joined JBoss full-time and became the Drools Flow lead. He has a keen interest in the healthcare domain, one of the areas that have already shown to have a great need for a unified process, rule and event processing framework.

Choose from the following live events:
Time zone converter

• Wednesday, February 22, 2012 | 14:00 UTC / 9am (New York) / 3pm (Paris) / 7:30pm (Mumbai)
• Wednesday, February 22, 2012 | 19:00 UTC / 2pm (New York) / 8pm (Paris) / *Thur 12:30am (Mumbai)

It's been a while since I last posted anything on the Software Transactional Memory work that's been going on in JBossTS (aka Narayana). At that time we had everything in place for you to write transactional applications that have all of the ACID properties or, more common for STM, without the D. Per object concurrency control is done through locks and type specific concurrency control is available. You can define locks on a per object and per method basis, and combined with nested transactions this provides for a flexible way of structuring applications that would typically not block threads unless there is really high contention:

@Transactional

public class SampleLockable implements Sample

{

public SampleLockable (int init)

{

_isState = init;

}

@ReadLock

public int value ()

{

return _isState;

}

@WriteLock

public void increment ()

{

_isState++;

}

@WriteLock

public void decrement ()

{

_isState--;

}

@State

private int _isState;

}

If you recall from previous articles, all but the @Transactional annotation are optional, with sensible defaults taken for everything else including locks and state. And you create and use instances fairly simply:

RecoverableContainer theContainer = new RecoverableContainer();

Sample obj1 = theContainer.enlist(new SampleLockable(10));

However, the locking strategy we had originally was pessimistic. As I mentioned separately:
"Most transaction systems utilize what is commonly referred to as pessimistic concurrency control mechanisms: in essence, whenever a data structure or other transactional resource is accessed, a lock is obtained on it as described earlier. This lock will remain held on that resource for the duration of the transaction and the benefit of this is that other users will not be able to modify (and possibly not even observe) the resource until the holding transaction has terminated. There are a number of disadvantages of this style: (i) the overhead of acquiring and maintaining concurrency control information in an environment where conflict or data sharing is not high, (ii) deadlocks may occur, where one user waits for another to release a lock not realizing that that user is waiting for the release of a lock held by the first."
And the obvious alternative to this approach is optimistic:
"Therefore, optimistic concurrency control assumes that conflicts are not high and tries to ensure locks are held only for brief periods of time: essentially locks are only acquired at the end of the transaction when it is about to terminate. This kind of concurrency control requires a means to detect if an update to a resource does conflict with any updates that may have occurred in the interim and how to recover from such conflicts. Typically detection will happen using timestamps, whereby the system takes a snapshot of the timestamps associated with resources it is about to use or modify and compares them with the timestamps available when the transaction commits."
Therefore, you can probably guess what's just been added to our STM implementation? Yes, that's right ... optimistic concurrency control! In line with the annotation based approach we've used so far, there are now two new annotations: @Optimistic and @Pessimistic, with Pessimistic being the default. These are defined on a per interface basis and define the type of concurrency control implementation that is used whenever locks are needed:

@Transactional

@Optimistic

public class SampleLockable implements Sample

{

public SampleLockable (int init)

{

_isState = init;

}

@ReadLock

public int value ()

{

return _isState;

}

@WriteLock

public void increment ()

{

_isState++;

}

@WriteLock

public void decrement ()

{

_isState--;

}

@State

private int _isState;

}

And that's it. No other changes are needed to the interface or to the implementation. However, at present there is a subtle change in the way in which you create your objects. Recall how that was done previously and then compare it with the style necessary when using optimistic concurrency control:

RecoverableContainer theContainer = new RecoverableContainer();

Sample obj1 = theContainer.enlist(new SampleLockable(10));

Sample obj2 = theContainer.enlist(new SampleLockable(10),

theContainer.getUidForHandle(obj1));

In the original pessimistic approach the instance obj1 can be shared between any number of threads and the STM implementation, along with JBossTS, will ensure that the state is manipulated consistently and safely. However, with optimistic concurrency we need to have one instance of the state per thread. So in the above code we first create the object (obj1) and then we create a copy of it (obj2), passing a reference to the original to the container.
It is likely that the API for this will change soon in order to unify optimistic and pessimistic: the aim is to make it as opaque as possible to the application so you only have to modify an annotation when you want to change the implementation. One other thing that we're considering is changing the implementation dynamically, perhaps based on monitored metrics for contention. But for now that's it and it's all available in the Narayana git repository.

Work has been completed to enable users to upload their XLS based Decision Tables into Guvnor! Checkout this new feature in the master branch (or wait for the arrival of 5.4.CR1 when it becomes available...)

Checkout a demo here.

Uploading a XLS decision table results in the creation of numerous new assets, including (obviously) web-guided Decision Tables, functions, declarative types and modifications to package globals and imports etc (Queries are not converted, although supported in the XLS form, as Guvnor doesn't support them yet).

XLS decision table



Guided decision table



This is the first stage of "round-tripping" decision tables. We still need to add the ability to export a guided decision table back to XLS, plus we'd like to add tighter integration of updated XLS assets to their original converted cousins - so if a new version of the XLS decision table is uploaded the related assets' versions are updated (rather than creating new) upon conversion.

This is a powerful enhancement and as such your feedback is critical to ensure we implement the feature as you'd like it to operate. Check it out, feedback your opinions and help guide the future work :)

A serious problem that we've faced internally in making a framework like Errai work nicely is the sometimes unpredictability of the order in which client-side services initialize. Non-GWT client-side developers working with jQuery often run into a similar problem.

For a long time, we've had various mechanisms to manage this problem. Well, it's really the same mechanism spread across many components -- "post-init" callback events.

It's a good pattern, works good and it's intuitive enough to work with. But with Errai 2.0, we've added a set of new features when working inside Errai IOC/CDI. We lovingly call them "Lifecycle Tools" in our new documentation for them, which you can find here .

It's easy enough to register callbacks and wait to be called back to. But since Errai has heavy emphasis on dependency injection, this problem seemed ripe for a nice, clean, don't-call-us-we'll-call-you approach.

So, when you have a client side bean -- and I use @Singleton here for maximum compatibility if you're not using CDI -- you can merely declare a startup dependency on your component by, well, injecting a startup dependency!



@Singleton

public class  MyClientBean  {

&nbsp;&nbsp; @Inject&nbsp; InitBallot<MyClientBean>&nbsp;ballot;



&nbsp;&nbsp; @PostConstruct

&nbsp;&nbsp; public&nbsp; void&nbsp; doVote ()&nbsp;{

&nbsp;&nbsp;&nbsp;&nbsp; //&nbsp;do&nbsp;lots&nbsp;of&nbsp;initializy&nbsp;stuff.

&nbsp;&nbsp;&nbsp;&nbsp;

&nbsp;&nbsp;&nbsp;&nbsp; ballot.voteForInit () ;

&nbsp;&nbsp; }

}


This code ensures that initialization of framework services will need to be delayed until it can do whatever work needs to be done. The parameterizing of the InitBallot is the way in which we categorize the dependency. You don't actually have to use the declaring classname. But the dependency must be unique. For instance InitBallot<Foo> will create a dependency on the class Foo . This is purely symbolic. But if the service fails to dial home with a voteForInit() call, in the bootstrap error message, it will be Foo that will be reported as the failed dependency. So keep that in mind.

Doing Stuff After...

There's of course the other obvious side to this coin. Which is wanting to do things only after you know all the framework services are initialized, happy, and doing their best Elvis dance. This job calls for our latest annotation, lovingly inspired by @PostConstruct , the wonderfully new and shiny @AfterInitialization annotation.

This is about as straight-forward as it gets. You create a method in your bean, and you... annotate it! When all the crazy things Errai does to bootstrap are done (bus federation, rpc proxies loaded, marshallers ready), your method will get called! It works like, and basically has all the same restrictions as @PostConstruct and so you use it like so:



@Singleton

public&nbsp;class&nbsp; MyClientBean&nbsp; {



&nbsp;&nbsp; @AfterInitialization

&nbsp;&nbsp; public&nbsp; void&nbsp; doStuffAfterInit ()&nbsp;{

&nbsp;&nbsp;&nbsp;&nbsp; //&nbsp;do&nbsp;lots&nbsp;of&nbsp;after-initialzy&nbsp;stuff!

&nbsp;&nbsp; }

}


... And there's all there is to it!

The only downside is this feature is not in our 2.0.Beta1 release (Boo!). But it is in our latest 2.0-SNAPSHOT release, and will be in the 2.0.Beta2 release. So if you're daring you can use it now, or you can wait for Beta2 which is right around the corner.

Mike, out.

There's really not a lot more I can say to describe how happy I am that we've just released AS7.1 and it's fully EE6 certified! The entire team has worked flat out for months (years!) to achieve this and not only have they done it, but they've done it with style! I'm not going to say much more because there are a plethora of blog posts out there already telling you all about AS7.1 so you should go take a look for yourselves. All I will add is that this is the start of the final lap for the EAP 6 release, so it won't be long before we'll be offering a fully supported EE6 platform to our customers as well as the community. Just watch this space!

 

Oh and for those who didn't see Jason's original email announcing the release, here it is:

 

Hi Everyone,

 

I am extremely excited to announce that JBoss AS 7.1.0.Final

"Thunderbird" has been released. This is the first JBoss AS release to

be certified under the Java EE6 Full profile. On top of that it brings

numerous management, security, and clustering enhancements. Altogether

this was a grueling release with 590 Jira issues resolved (we only set

out to do 311!), which brings us to a combined total of 1465 issues

resolved since 7.0.2.Final!

 

So, a very large thank you is in order to all of our contributors who

had a part in this release. All of those hours working around the clock

to make this happen have finally paid off!

 

Check out the extensive release notes here:

https://community.jboss.org/wiki/AS710FinalReleaseNotes

 

As always, you can download it here:

https://www.jboss.org/author/jbossas/downloads.html

 

Thanks, and as a mentor once said,

 

Onward!

Great news for the Java EE Community and the fantastic JBoss AS/EAP development team, who can at last get some sleep(!): JBoss AS 7.1 was released!

The code name of the release is Thunder, emphasizing one of the main characteristics of the JBoss AS7 personality: speed! The server boots in just 2.2secs in the default profile on my humble laptop with two thirds of the services actually started, not just lazily loaded! I am soon expecting another round of people experimenting with the start-up parameters to achieve sub-second start-up times!

The number of JIRAs resolved in the 7.1 series in total (from the Alpha version down to Final) since 7.0.2 was released last September, reached the record number of 1465 issues, so you can imagine how big is the delta between the two releases and how productive the development team has been.

Jason has summed up pretty nicely what's new with JBoss AS 7.1 in the release notes which is a must read.

However, the big news with this release is the achievement of Java EE6 Full Profile certification. It took us a while to get there, mostly because the architecture of JBoss AS was essentially redesigned in order to address the pain points of the previous iteration and accommodate an ever increasing set of requirements.

But we are confident that the end result is pleasing for developers and administrators alike. JBoss AS7.1 is smaller, faster and more manageable than any previous JBoss AS release and really pushes the envelope in terms of Application Server technology.

In other words JBoss AS got its Mojo back. It is fully functional and sexy!

Give it a spin and let us know.

Enjoy
/Dimitris

After just about more than a year of development on JBoss AS7, we have now released 7.1.0.Final "Thunder" ! The download is available at the usual place here . This is a really big achievement for the JBoss AS7 team and we are really proud about this release.

This release contains numerous bug fixes from 7.1.0.CR1b which was released a few months back. But the biggest news about this release is that JBoss AS 7.1.0.Final is Java EE 6 Full Profile certified ! I'm sure a lot of our users will be very happy about this news. AS 7.0.x was Web Profile certified but I have seen in the forums that many of you were waiting for the Full Profile certification to happen. So here's a very good reason to start using JBoss AS7, if you haven't done yet.

Apart from the Full Profile certification, AS 7.1.0.Final contains a lot of bug fixes and other JIRA issues resolved. The entire release notes can be found here .

Like in some of my previous posts on AS7 releases, in this post I'll explain atleast one new feature of this release. Many of you would know that JBoss AS7 is very different compared to the previous JBoss AS versions, on various counts. One prominent difference is that we no longer have numerous XML files in the distribution, configuring various services. Instead we just have *one* single configuration file which governs the entire server. Furthermore, unlike previous JBoss AS versions, JBoss AS7 (prior to 7.1.0.Final) did not allow *deploying* XML files to configure datasources and JMS queues. However, the community members have been repeatedly asking for this feature and JBoss AS 7.1.0.Final now allows deploying of datasources and JMS queues via application specific XML files (in addition to configuring them centrally in the domain/standalone configuration file). So let's take a quick look at how it's done in 7.1.0.Final.
Deploying datasource via -ds.xml files in JBoss AS 7.1.0.Final The datasource file is expected to end with the -ds.xml suffix, like in previous JBoss AS releases. You can place the *-ds.xml file in the JBOSS_HOME/standalone/deployments folder or even package it in the application under the META-INF folder of the application. If it's a .war application, then the *-ds.xml is expected to be right under the WEB-INF folder of the .war.

The *-ds.xml is expected to follow the jboss-as-datasources xsd which looks like this (you can find this xsd in the JBOSS_HOME/docs/schema folder of your installation too). So you have a datasources element under which you can define multiple datasource elements. In this example, we'll try and create a MySQL datasource and deploy it as&nbsp; mysql-ds.xml.

Before creating the datasource, we first have to install the database driver. AS7 allows you install the database driver either as a deployment or as JBoss Module . For more details on this, see this article . In this post, we'll deploy the driver as a JBoss Module.

Create and install the database driver As a first step, we'll require the MySQL driver jar file. I downloaded the driver jar from the MySQL download site here . The step to create the JBoss Module for this driver involves creating a module.xml which looks like this and is named module.xml:

 <module xmlns="urn:jboss:module:1.1" name="mysql">  

   

   <resources>  

     <resource-root path="mysql-connector-java-5.1.18-bin.jar"/>  

   </resources>  

   <dependencies>  

     <module name="javax.api"/>  

     <module name="javax.transaction.api"/>  

   </dependencies>  

 </module>  

We place the mysql-connector-java-5.1.18-bin.jar and this module.xml file in JBOSS_HOME/modules/mysql/main folder (you'll have to create the mysql/main folder). That completes the JBoss Module creation for the MySQL driver. Now let's install this driver so that it gets registered in the standalone/domain configurations. In this example, we'll be using the standalone server. So let's start the server using:

 ./standalone.sh  

Once the server is up, let's open the Command Line Interface (CLI) utility which is shipped in AS7. The CLI startup script is in the JBOSS_HOME/bin folder and can be started as follows (more details about the CLI can be found here )

 ./jboss-cli.sh --connect  

Once connected successfully, we'll add the jdbc-driver using the following command:

 /subsystem=datasources/jdbc-driver=mysql-5-driver:add(driver-name=mysql-5-driver, driver-class-name=com.mysql.jdbc.Driver, driver-module-name=mysql)  

So here we are naming the driver as "mysql-5-driver" (you can name it anything). The driver-module-name points to the "mysql" JBoss Module that we created in previous step. The driver-class-name is the fully qualified classname of the MySQL driver. In this case, it's com.mysql.jdbc.Driver.

A successful execution of that command will show the output as success:

 [standalone@localhost:9999 /] /subsystem=datasources/jdbc-driver=mysql-5-driver:add(driver-name=mysql-5-driver, driver-class-name=com.mysql.jdbc.Driver, driver-module-name=mysql)  

 {"outcome" => "success"}  

   

The installation will be persisted in the configuration file which was used to start the server. In this case it's the standalone.xml and this is how it looks like after the driver has been installed:

 <subsystem xmlns="urn:jboss:domain:datasources:1.0">  

      ...  

           <drivers>  

                ...  

                <driver name="mysql-5-driver" module="mysql">  

                     <driver-class>com.mysql.jdbc.Driver</driver-class>  

                </driver>  

           </drivers>  

      </datasources>  

 </subsystem>  

We are now done with the driver installation. Now let's move on and create the mysql-ds.xml file.

Create the mysql-ds.xml file As previously mentioned, the mysql-ds.xml should follow the jboss-as-datasources xsd . Here's how the file looks like in our case:

 <?xml version="1.0" encoding="UTF-8"?>  

 <datasources>  

   <datasource jndi-name="java:jboss/datasources/MySQLDS" enabled="true" use-java-context="true"  

         pool-name="MySQLDS">  

     <connection-url>jdbc:mysql://localhost:3306/test</connection-url>  

     <driver>mysql-5-driver</driver>  

     <security>  

       <user-name>foo</user-name>  

       <password>bar</password>  

     </security>  

   </datasource>  

 </datasources>  

Let's see what that xml file contains. The "jndi-name" is the name to which the datasource will be bound to (you can use a name of your choice. Ideally, it would be good to bind them in java:jboss/datasources/ namespace). The "enabled=true" indicates that the datasource should be enabled after being deployed. The "use-java-context" attribute is used to indicate that the JNDI name should be bound under the java: namespace. The "connection-url" is the URL to be used for connecting to the MySQL database (check MySQL documentation for more details about the connection-url). The "driver" element points to the installed JDBC driver that we created in the previous step. In our example, we named it mysql-5-driver and that's what we use here. Finally, the "security" section contains the username and password information for connecting to the database. Make sure you use the appropriate values for all these configurations.

So now let's place this mysql-ds.xml in the JBOSS_HOME/standalone/deployments folder and see JBoss AS7 hot deploy it (if the server is already running). The logs will show the following on successful deployment:

 14:05:55,829 INFO [org.jboss.as.server.deployment] (MSC service thread 1-3) JBAS015876: Starting deployment of "mysql-ds.xml"  

 14:05:55,847 INFO [org.jboss.as.connector.subsystems.datasources] (MSC service thread 1-2) JBAS010400: Bound data source [jboss/datasources/MySQLDS]  

   

So that's it! We have successfully deployed the MySQL datasource through a -ds.xml file in 7.1.0.Final!

So download this new version and start deploying your applications and start using these features. We'll be blogging more about the features in this release, in the upcoming days (after the AS7 developers get some much needed sleep :) ). So keep an eye on the jboss.org blogs . If you run into any issues with AS7, feel free to visit our user forum and ask for help.

[AS7 Home ] [AS7 JIRA ] [AS7 User Forum ] [AS7 documentation ] [AS7 downloads ] [AS7 nightly builds ]

It's just mid-February and a great number of achievements is already behind us this year. More to come. The first big item of news this week is the release of the final version of JBoss AS 7.1.

 

Thunder follows lightning (closely, as always)

 

You've seen the lightning, now hear the thunder. It may be just a minor version change, but by no means this is a minor event: JBoss AS 7.1.0.Final "Thunder" is out, one of the largest releases in JBoss history. The new release brings in a whole slew of features and stability fixes, the most significant being a certified full Java EE 6 profile, which adds support for a number of new specifications on top of the already certified Java EE 6 Web Profile available as of the release of JBoss AS 7.0.0.Final "Lightning". No less than 1465 issues have been fixed since JBoss AS 7.0.2.Final, and they account for the new features added as well as improvements in areas such as security, management and clustering.

 

What do you need to know:

• The fully certified Java EE6 profile brings support for a number of specifications - including EJB 3.1 asynchronous and remote invocation, timers and message-driven beans,
• The security model is more strict, with remote access points (except web applications) being secured by default;
• Management capabilities have been enhanced - through an improved management API, CLI and administration console - on the latter, more details are outlined here by Heiko Braun;
• Remote connectivity capabilities have been enhanched - not only for EJB access but also in the area of distributed transactions;
• Clustering support includes web and EJB replication, and  experimental CDI replication as well.

 

You can learn all the details in the release notes, while downloading the new release!

 

JBoss EAP 5.1 Common Criteria certified

 

We usually write about the bleeding edge of Java EE technology and community projects. It is, sometimes, interesting to learn about latest developments regarding JBoss commercial products, like the news shared by Anil Saldhana - that JBoss EAP 5.1.0 and JBoss EAP 5.1.1 have just received their Common Criteria certification at EAL4+ level. What does this mean? In short, it has been audited and found to fulfill the highest requirements for security-sensitive environments (like government customers).

 

J is for Java

Following last week's post, Mark Little provides a more detailed perspective on his vision about the future of Java as a suitable platform in the age of polyglot software development: Java continues to be the foundation and powerhouse of the JBoss enterprise platform, while developers will be able to use their language of choice, owing to approaches such as TorqueBox or Immutant.

 

The Trailblazer SIG is born!

 

Help creating better JBoss developer resources such as examples, tutorials or screencasts by participating in the newly created Trailblazer SIG!  We already have a number of initiatives in place, and that's just the start - with your participation it could be much, much more! Stay at the forefront of Java EE innovation, join us now!

 

Infinispan: how would you like your cross-data center replication?

 

If you are interested in of cross-datacenter replication - Mircea Markus is asking on the behalf of the Infinispan team for suggestions and feedback on the design of this functionality, eyeing for its implementation in 5.2.0.

 

New releases

 

With its 4.1.0 version, which has been released last week, Hibernate Core gets a name which will, hopefully improve the clarity of its purpose: Hibernate ORM. In the announcement blog post, Steve Ebersole is explaining why, as well as what you can find in the new release.

 

Hibernate ORM is not the only member of the family that gets a new release - while announcing Hibernate Search 4.1.0.Beta2, Sanne Grinovero discusses an important new feature: the ability of specifying the indexing path for embedded entities, thus allowing better control over what exactly gets indexed in a complex structure. Worth trying! To me, however, the lesson about the importance of community feedback in framework design is equally interesting - another reason to read Sanne's post.

 

Errai continues its race towards building a better rich web experience for Java developers with the completion of its 2.0.Beta1 version. Jonathan Fuerth is providing a comprehensive overview of the release as well as the upcoming roadmap.

 

If you are looking for deeper integration between Spring and JBoss, Snowdrop 2.0.2.Final is out, with a number of fixes related to Spring 3.1 support.

 

Teiid 8.0.0 alpha 2 has been released as well.

 

Sightings

If you happen to be in Brno, make sure that you are not missing the Fedora Conference this weekend (17-18 February) - a lot of JBoss tracks - see the schedule here.

 

A JBPM 5 webinar is scheduled next week on 22 February.

 

This is all for this week, join us again in a week's time for latest and freshest in the ever-evolving world of JBoss.

 

 

 

 

 

 

 

 

 

 

A Quick Tour of Errai 2.0
The first beta of Errai 2.0, 2.0.Beta1, is now available! You can download the release in a zipfile , or–even simpler–use one of our archetypes to get started right away.

In this post, I will walk you through all the bits and pieces of the framework as it stands today, and I will wrap up with a peek at the future. But first, let's look at where and why we started this project, and what motivated us to take it where it is today.

The Past
Errai started with the vision that, as browsers become more and more capable computing platforms, the complexity of codebases we write for the browser will grow. Although the ECMAScript language has matured significantly over the years in terms of features, uniform behaviour across browsers, and speed of execution, it still remains true to its roots as a scripting language: loosely typed, little support for encapsulation, poor support for immutable types, and no direct linguistic support for namespaces. Perhaps most importantly, ECMAScript is a slippery target for refactoring and navigation tools.
The idea behind the Errai Framework is that we (Java developers) have already learned how to develop large code bases, managing their complexity with an array of tools and practices that are simply not available to us in other environments:

• Completely safe refactorings such as rename, move, extract to method, and more
• Typesafe code completion with popup API documentation
• The ability to create truly immutable objects
• Test-driven development using JUnit
• IDEs that highlight dead code, unused methods, and unsafe casts
• Static analysis with FindBugs, CheckStyle, and PMD
• Advanced step-by-step debugging tools

Errai's vision is that we can and should apply these advantages to the increasingly intricate codebases we write for the client side of today's modern web applications.

The Present
With Errai 2.0, we're taking a big step toward the realization of Errai's vision: to provide a uniform, familiar, and well-tooled programming model across client and server. Yes, Errai 1.x provided a uniform programming model across client and server, providing its own publish/subscribe bus API and its own RPC API. Those APIs remain in place, but we now think of them as lower-level enablers. With Errai 2.0, we've begun implementing Java EE 6 APIs on top of the base APIs in Errai 2.0. So far, we support CDI in the client, as well as a JAX-RS client API.

High-level APIs in Errai 2.0
CDI in the Browser
With CDI in the browser, not only can you @Inject dependencies into your beans, but you can also @Observe events that occur both locally (on the client) as well as remotely (on the server.) Naturally, the inverse is true: events fired on the client are observable on the server. To be clear, all of the following are possible:

• Client-local communication (fire and observe events within the browser)
• Server-local communication (this is just traditional CDI eventing)
• Server-to-client communication (Errai pushes server events to the client)
• Client-to-server communication (Errai pushes events from the client to the server)

Underlying this feature is the good old Errai Bus, which will ensure that events are only routed across the wire if there are actually observers interested in that event on the other end of the connection. No HTTP traffic for local events.

Here's what it looks like:
Server Side @ApplicationScoped public class TickerService {
&nbsp; @Inject &nbsp; private Event<Tick> tickEvent ;
&nbsp;&nbsp;private void sendTick() { &nbsp; &nbsp;&nbsp;tickEvent .fire(new Tick()); &nbsp; } }&nbsp; Client Side @EntryPoint public class TickerClient { &nbsp;&nbsp;public void tickHappened(@Observes Tick tick) {
&nbsp; &nbsp;&nbsp; // update the UI with the new data &nbsp; }
}
To dig in further, use the Errai-CDI quickstart archetype to generate a project you can play with.
JAX-RS Client
New in Errai 2.0 is the JAX-RS client. This is a true JAX-RS client framework. It does not route messages over the Errai Bus; it makes direct AJAX (XMLHTTPRequest) calls to the JAX-RS resource methods on the server side. Of course, all the object marshalling is taken care of on both sides, just like with bus messaging.

Sticking with the theme of "familiar," you simply implement your server-side resources with standard JAX-RS annotations, and on the client, you use exactly the same code as you would use for Errai RPC calls. A great new feature with no new APIs!

Here's a taste:

Server Side @Path ( "customers") public interface &nbsp; CustomerService { &nbsp; @GET &nbsp; @Produces ( "application/json") &nbsp; public &nbsp;List<Customer> listAllCustomers(); }
public class CustomerServiceImpl implements CustomerService { &nbsp;&nbsp; @Override &nbsp;&nbsp;public List<Customer> listAllCustomers() { &nbsp; &nbsp; List<Customer> customers = CustomerDAO.getAll(); &nbsp; &nbsp; Collections.sort(customers); &nbsp; &nbsp; return customers; &nbsp; } } Client Side @EntryPoint public class CustomerClient { &nbsp;&nbsp; @Inject &nbsp; private Caller<CustomerService> customerService ;
&nbsp;&nbsp;private void populateCustomersTable() { &nbsp; &nbsp;&nbsp;RemoteCallback<List<Customer>> listCallback = &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp;new RemoteCallback<List<Customer>>() { &nbsp; &nbsp; &nbsp; public void callback(List<Customer> customers) { &nbsp; &nbsp; &nbsp; &nbsp; addCustomersToTable(customers); &nbsp; &nbsp; &nbsp; } &nbsp; &nbsp; }; &nbsp; &nbsp; customerService .call(listCallback).listAllCustomers(); &nbsp; } }
To dig in further, use the Errai JAX-RS archetype to generate a project.

Errai RPC
Errai RPC remains an important high-level API in Errai 2.0. And since it's identical to the JAX-RS client API at the call site, you are free to switch between Errai Bus and RESTful communication simply be re-annotating your server-side code. The client remains untouched. Here's how it looks (notice that the client code is identical to the JAX-RS example):
Server Side
@Remote public interface &nbsp; CustomerService&nbsp;{ &nbsp;&nbsp;public &nbsp;List<Customer> listAllCustomers(); }

@ApplicationScoped @Service public &nbsp;class &nbsp;CustomerServiceImpl&nbsp;implements &nbsp;CustomerService { &nbsp;&nbsp; @Override &nbsp;&nbsp;public &nbsp;List<Customer> listAllCustomers() { &nbsp; &nbsp; List<Customer> customers = CustomerDAO.getAll(); &nbsp; &nbsp; Collections.sort(customers); &nbsp; &nbsp;&nbsp;return &nbsp;customers; &nbsp; } } Client Side
@EntryPoint public class &nbsp;CustomerClient { &nbsp;&nbsp; @Inject &nbsp;&nbsp;private &nbsp;Caller<CustomerService>&nbsp;customerService ;
&nbsp;&nbsp;private &nbsp;void &nbsp;populateCustomersTable() { &nbsp; &nbsp;&nbsp;RemoteCallback<List<Customer>> listCallback = &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp;new &nbsp;RemoteCallback<List<Customer>>() { &nbsp; &nbsp; &nbsp;&nbsp;public &nbsp;void &nbsp;callback(List<Customer> customers) { &nbsp; &nbsp; &nbsp; &nbsp; addCustomersToTable(customers); &nbsp; &nbsp; &nbsp; } &nbsp; &nbsp; }; &nbsp; &nbsp;&nbsp;customerService .call(listCallback).listAllCustomers(); &nbsp; } }
And like Errai CDI, client and server code are interchangeable. You could swap these client and server code snippets, or put both on the client, or both on the server, and they would sill be able to communicate with each other.

To try Errai RPC yourself, clone our Errai Kitchen Sink quickstart (note this quickstart also uses JPA, JAX-RS, CDI, and Bean Validation, and it's only set up to work in JBoss AS 7 at the moment.)

Lower-level APIs in Errai 2.0
Errai Bus and&nbsp;MessageBuilder
If you're familiar with Errai from the 1.x days, you'll already be familiar with the Errai Bus. The bus remains central to the workings of&nbsp; most Errai high-level features, including CDI remote eventing and Errai RPC (JAX-RS is the exception; it's independent of the bus.)
Using the low-level Errai Bus API, you can send messages on a particular subject and register/deregister callbacks that receive messages on a particular subject. Naturally, the API for doing this on the client or the server is the same.
MessageBuilder is a fluent API for constructing (and optionally transmitting) Errai Bus messages. Although we're now leading with the higher-level APIs, MessageBuilder remains available as a convenient way to construct Errai Bus messages "by hand." Of course, the above-mentioned high-level communication features are actually using the MessageBuilder API on your behalf.
Server Side
@ Service public class HelloWorldService implements MessageCallback { &nbsp; public void callback(Message message) { &nbsp; &nbsp; MessageBuilder.createConversation(message) &nbsp; &nbsp; &nbsp; .subjectProvided() &nbsp; &nbsp; &nbsp; .withValue( "Hello, World! The server's time is now " + new Date() + ".") &nbsp; &nbsp; &nbsp; .done().reply(); &nbsp; } } Client Side
@ EntryPoint public class HelloWorldClient extends VerticalPanel { &nbsp;&nbsp;@ Inject &nbsp; private MessageBus bus ;
&nbsp;&nbsp;void sendMessage() { &nbsp; &nbsp; MessageBuilder.createMessage() &nbsp; &nbsp; &nbsp; &nbsp; .toSubject("HelloWorldService" ) &nbsp; &nbsp; &nbsp; &nbsp; .withValue("Hello, There!" ) &nbsp; &nbsp; &nbsp; &nbsp; .done() &nbsp; &nbsp; &nbsp; &nbsp; .repliesTo(new MessageCallback() { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; public void callback(Message message) { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp;responseLabel .setText( &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; message.get(String.class , MessageParts.Value)); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; } &nbsp; &nbsp; &nbsp; &nbsp; }) &nbsp; &nbsp; &nbsp; &nbsp; .sendNowWith(bus ); &nbsp; } }
To play with a working project that uses MessageBuilder, just use the Errai Bus quickstart archetype . Enabling Technologies
Errai-codegen
Because we use the GWT compiler to bring all this great stuff to the browser, and because GWT eschews runtime reflection in favour of up-front code generation, most Errai features are centred around generating Java source code to feed into GWT at compile time. Because we're such believers in the value of static type checking, we felt compelled to do something a little more structured than just spitting strings into a file and hoping that the result was a well-formed Java source file. Enter Errai's code generator.
Errai-codegen is a fluent API for generating Java source code. It provides static type checking and variable scope checking as it goes, and its promise to you is that it will not allow the creation of a class that can't compile. It also does a really nice job of formatting its output.
Do you generate Java code in any of your projects? Feel free to try out our code generator and let us know what you think. We'd love to hear from you!
Server Side (typically runs at compile time)
Context ctx = Context.create(); String s = StatementBuilder &nbsp; &nbsp;&nbsp;&nbsp; &nbsp; &nbsp; &nbsp;&nbsp; .create() &nbsp; &nbsp; &nbsp; &nbsp;&nbsp; &nbsp; &nbsp; .declareVariable("n" , Integer.class , 10 ) &nbsp; &nbsp; &nbsp; &nbsp;&nbsp; &nbsp; &nbsp; .generate(ctx);
assertEquals( "Integer n = 10;" , s);
VariableReference n = ctx.getVariable("n" );
assertEquals("n" , n.getName()); assertEquals(MetaClassFactory.get(Integer.class ), n.getType()); assertEquals(LiteralFactory.getLiteral(10), n.getValue());



Errai Marshalling

Every object sent across the Errai Bus, as well as the JSON representations sent and received by your JAX-RS resources, is represented as a JSON object. Errai provides a robust marshalling framework that aims to provide maximum flexibility while imposing minimum markup on your code.

Errai's Marshalling framework includes all of the following techniques, which you can mix and match as you like, based on where you place your annotations:

• Private/default/protected/public field read & write
• Setter and Getter property access
• Provide all properties to the constructor - my favourite because it allows for marshalling properly immutable types
• Out-of-the-box support for marshalling all JDK classes that are GWT translatable
• Custom marshallers for those really hard-to-reach classes :)

Errai IoC
Although Errai supports dependency injection via CDI, CDI remains an optional module for now. If you choose not to use it, you can still use @Inject annotations to obtain references to Errai-provided dependencies such as Sender<?> and Caller<?>. And of course, this works the same in client code and server code.

The Future
Of course, we have our eyes on the horizon beyond Errai 2.0. The theme of our longer-term plans is to continue providing Java EE 6 functionality within the client, while providing a practical framework to keep your app running offline, when the server is unavailable.
JPA with Sync

For starters, you probably already have JPA annotations on your model objects. We plan to breathe life into them on the client side. Errai's JPA module will allow you to store and query your model objects locally on the client for speedy access and for storage and retrieval when the web server can't be contacted. We also plan to add features that will make data synchronization as painless as possible when the server does come back.


Shadow Services
Speaking of offline, I've already mentioned a couple of times that Errai Bus can deliver messages locally as well as remotely. When the server goes away, the local bus remains fully operational in the webpage. This means you can already create services within the client, and the calling code doesn't look any different: the bus itself makes the routing decisions.

We plan to take full advantage of this behaviour by having the client-side bus automatically deliver messages to local "shadow" services when the remote ones are unavailable. Combined with client-side JPA, we hope this will make for a really slick programming model for webapps that keep on tickin' when the server is unreachable.


JBoss Forge

We love Forge, and we can't wait to start using it to build Errai projects. Forge's existing JPA scaffolding will already help you quite a bit with an Errai app, but we can extend that further to make the necessary objects marshallable, and maybe even generate some UiBinder templates. Exciting times ahead!


And maybe you have some ideas! What other parts of the EE 6 suite of APIs do you wish you could use in client-side code? What tooling would make this even better? Come to our discussion forum and let's talk!