Lots of exciting developments in the GlassFish ESB world; hot on the heels of the GlassFish ESB v2 release candidate with its enterprise features and commercial support we're also showing that we have more big plans for the evolution of this platform. With Milestone 3 of Project Fuji we give you the keys to test drive some of the platform enhancements we're working on for GlassFish ESB.next and allow you to be an active participant in driving the direction.

If you haven't been following Project Fuji closely you might be interested to know that there is both an "evolutionary" and "revolutionary" side; Adapters and Containers from v2 also are used in Fuji, and applications built in v2 deploy and run on Fuji. Where we're innovating is in looking at the productivity in every layer; ensuring we are tops in flexibility, agility and ease of use.

Milestone 3 of Project Fuji introduces a (dare I say very cool) web based tooling option for composing services.

Check out the Fuji Milestone 3 Screencast which shows how to use simple drag and drop in a browser to easily build the same scenario that was built in Milestone 2 via the domain specific language "IFL" for composing services.

It's worth noting that the web tooling builds on top of the domain specific language and hence round tripping is easy; you can for example check out the project built in the browser from subversion and edit it in your IDE of choice, just as shown in milestone 2.

This gets us one step closer to the mantra of Fuji: Productivity through flexibility, agility, and ease of use.

• In terms of flexibility this expands your tooling choices
• For agility you might notice the "automatically save and deploy" option which is one step towards our goal of making it very light weight to develop, test and correct your application as you go along
• For ease of use the simple way of visually modeling enterprise integration patterns and simple properties dialogs go a long way

Many of you may have seen the cool things Fuji Milestone 1 did, with its web based tooling option and the simple but powerful way of defining services and linking them together. For Milestone 1 we deliberately chose some contemporary technologies such as RSS and XMPP, which left some folks wondering: how does this apply to the more classic integration scenarios?

Fear not, for Milestone 2 we have chosen a classic scenario and show you how quick and easy it is to solve it with the powerful, but simple to use capabilities in Fuji.

Don't just take our word for it, watch the Fuji Milestone 2 Screencast with Keith driving it. Then Download Milestone 2 and take it for a spin by getting a simple jar file and give us feedback! There actually are more features that we couldn't fit in a single screencast, so watch this space.

For a highlight of the features such as added enterprise integration patterns and interceptors leveraging OSGi capabilities see the Milestone 2 page. Also have a look at Andi's entry on Fuji Milestone 2, which includes further background info.

We also re-vamped the landing page for Fuji, have a look at our fancy schmancy portal page for Fuji https://fuji.dev.java.net, it should have all the links to explore further information, screencasts etc.

Note that tomorrow (October 22, 2008, 9am PT) we'll have a live meeting and webcast to demo and discuss Fuji in the OpenESB Innovation Series meeting, come and participate.

How do Event Processing, Event Stream Processing and Event-Driven Architecture relate to an ESB? Prashant explains in this blog entry and illustrates on an example of fraud detection.

Event driven architecture in Open ESB is enabled by the Intelligent Event Processor (IEP) component.

IEP is a Complex Event Processing (CEP) and Event Stream Processing (ESP) engine and comes with rich set of operators and a nice set of tools to visually handle events. As it plugs into Open ESB it can take advantage of all the external connectivity capabilities to gather and act upon events.

An introduction workshop to IEP is available here

Also check out Serge's blog for further in depth discussions of IEP, CEP and CQL.

With the advent of the GlassFish-powered OpenESB product, there's been some very interesting activity around SOA on java.net so here's a recap of SOA-related projects on java.net :

• OpenESB - the core project, implementing JBI, serving as the foundation to JavaCAPS and leveraging the GlassFish runtime.
• Project Mural - Master Data Management community. Get your feet wet with this Hands-On-Lab.
• Project Fuji - an experimental project building on GlassFish v3, OSGi, and JBI. Listen to Andi's presentation here.
• JBI Components - a collection of JBI components, Binding Components and Business Engines.

And some sister projects :

• KeyChain - ESB components for legacy application integration for SPML Provisioning gateway.
• OpenMQ - the high-performance JMS implementation that is integrated in both GlassFish and OpenESB.
• Metro Web Services - the one-stop-shop for Web Services from WS-I Basic Profile to advanced (secure, reliable, optimized, ...) SOAP web services.
• NetBeans. SOA without tools?

Expect a roadmap and vision document in the near future for how these pieces all come together (for those that don't already, that is).

An interesting mini talk on Dynamic Networks with JBI is now available in the JavaOne community corner podcasts. Travis Chase from Accenture's National Security Services division details how GlassFish and OpenESB helped them develop a solution that decreases the network set-up time to run an exercise from weeks to minutes.

The team developed and contributed several components to the community to achieve this, including the XMPP, SIP and RSS binding components; plus they leveraged several others of the 30+ components available in the OpenESB community. The strong web service capabilities of GlassFish were used to define the business logic on the ESB.

If these components look familiar, we used the same RSS and XMPP components in the Project Fuji screencasts to show how quick and easy it is to route and filter messages between these systems.

After a short hiatus, the GlassFish Podcast has two new episodes from a presentation delivered at the recent GlassFish Day at the Jazoon conference. The speaker is Andreas Egloff (a fellow editor on TheAquarium), and the topics are OpenESB and Project Fuji.

Episode #13 covers the existing OpenESB technology and community building on top of JBI and serving as a foundation to the JavaCAPS SOA offering from Sun, while Episode #14 covers the future of the project with GlassFish v3, OSGi, JBI and a DSL.

The podcast has the traditional syndication link, a one-click subscribe link for iTunes, but you can also simply search for "glassfish" on the iTunes online store if that's your software of choice.

Keith Babo has released a new ten minute screencast on Project Fuji's interceptor feature which intercepts messages as they travel across the NMR (Normalized Message Router) to implement alerts, auditing, validation, security, routing, and many more useful scenarios in a very non-intrusive way.

The interceptor itself is a Java POJO and this screencast goes into what it takes to develop the annotation, build the application and create an OSGi bundle, and finally install and start the interceptor in the Felix runtime. Interceptors are started and stopped independent of the application. Details on the Java @Interceptor annotation are available from this wiki page.

Project Fuji was announced at this past JavaOne and is the next generation OpenESB architecture based on GlassFish v3, OSGi, and JBI. It also features a top-down development language, IFL (Integration Flow Language) briefly shown in a previous screencast. Keep also an eye on the GlassFish Podcast for a Project Fuji presentation by tech lead Andreas Egloff. Previous entries on the topic are marked with the "Fuji" tag.

The goal of every specification (say Java EE 5) is to make sense as a whole and document how it relates to other specification and technologies. A product (say GlassFish) needs to augment the specification with a set of coherent features to provide yet a more powerful and competitive toolset. GlassFish v2 has Grizzly (the nio framework), OpenESB 2.0 (the JBI implementation) and will soon have a SIP capabilities with project SailFin. This enables James Lorenzen to build a JBI Binding Component for RSS in Java but also in Groovy. Speaking of OpenESB, the list of binding components and service engines available is growing fast and the OpenESB tooling is getting better by the day.

Probably one of the great strengths of Groovy is the ability to mix and match with Java. Any Java code (almost?) is valid Groovy code so you can introduce the dynamic and agile code to places requiring many fast changes while keeping the rest static and performing fast. Grails (a web application framework using Groovy) runs well on GlassFish and we're interested in making sure all the value-add from GlassFish (say Metro) is fully available to Groovy and Grails developers.

One of the many new features for GlassFish v2 is an integrated JBI implementation. Gregg Sporar has done some nice digging on that subject. To get your feet wet, he recommends this resource and the specification's first four chapters.

Since Gregg is a NetBeans evangelist, there's a tooling part of the story. The forthcoming NetBeans Enterprise Pack (version 5.5.1) has new and improved XML and SOA features such as a Service Assembly "casa" editor, graphical WSDL and XSLT editors, and an Intelligent Event Processor.

JBI implementations are listed here, while JBI components and engines are enumerated there. Most of these are Open Source and there are also examples of mix and matching such as this one.

ServiceMix is an Open Source ESB (under ASL license) that is based on JBI. Bhavani reports that ServiceMix now works in GlassFish v2. The default JBI runtime in GlasssFish v2 is Open-ESB but options are good for customers, and thanks to the Java EE Service Engine, ServiceMix can be used. Check Bhavani's blog for detailed instructions.

Milestone 3 for GlassFish v2 (aka v2b28) is now available for download, following M1 and M2. This release includes many new features and improvements; some of them are:

• Profile support (developer, enterprise, cluster)  • Initial Update Center Support.  • JSR-196 Public Draft.  • WS Interoperability (WSIT) Functionality Integrated.  • JBI Support Integrated.  • Partial Implementation of in-memory replication.  • Dynamic clustering from Shoal.  • Optimized ORB Integrated.  • Improved Startup Architecture.  • Improved Web Tier: Comet, virtual hosting, in memory JSP compilation, port unification.  • CLI improvements (including DWIM).  • JSF used in the Admin GUI.

More details in the GF v2 M3 Highlights page. Expect a few additions before the beta in February, but most of the functionality is already in this milestone. Download it here and let us know how it works for you.

The User Experience Meetings are continuing and our next one is tomorrow Wed, Nov 29, 2006 (PT). Presenter is Binod, on JBI Integration with GlassFish. Java Specification Request (JSR) 208, Java Business Integration, provides a standards-based integration architecture to enable composite application development. JBI runtime functionality is currently available in the Java EE 5 SDK. JBI allows you to integrate web services and enterprise applications as loosely coupled composite applications, thereby realizing the benefits of a SOA. Details on how to attend this meeting is at the UE Wiki Page.

Last week we released the First Milestone of GlassFish V2, which includes the New WS Implementation. The performance numbers are very nice but when we started talking with the Business Integration folks they asked for many (over 100,000) concurrent requests, each taking substantial (say over 5 minutes) time...

So, Kohsuke and Jitu have been exploring a refinement of the V2 WS implementation so it is Truly Asynchronous. This iteration would replace Pipe with Valve using the ideas of Fibers. The result is very very good scalability with minimal impact in response time. Check the slides here and here. This change is not yet committed into the GlassFish roadmap. Technical discussions are in the DEV mailing lists of WSIT and JAX-WS

Gopalan has been doing a whole collection of good writeups that would be very useful to learn BPEL. Gopalan is in the team that works on OpenESB (includes JBI); most of his entries relate strictly to BPEL but some address specifically BPEL and JBI. Gopalan, Ron, and John are some of the bloggers I enjoy reading in this area.

Entries on BPEL include:

• What are Correlation, Message Property, Property Alias, and Correlation Set
• What are PartnerLinkTypes, Roles, and PartnerLinks
• The BPEL Mapper
• The BPEL Debugger

Entries on the intersection on BPEL and JBI include:

• The WS-BPEL JBI Service Engine
• The HTTP/SOAP JBI Binding Component
• Insurance Claim Scenario: Orchestration using BPEL and JBI - This is based on J1 TS, see nice review
• Nice Follow-up Article based on the above (Ron's recommendation, TA spotlight).

An Enterprise Service Bus (ESB) is a distributed infrastructure where a set of service containers adapt IT assets to a standard model based on XML and Message Exchange Patterns (MEP). The ESB interconnects them with a reliable messaging bus and provides services for transforming and routing messages, as well as administration (see ron's entry or the Wikipedia page). ESBs are popular but they suffer from a lack of standarization, and the JBI specificiation (JSR 208, JBI.next) addresses that problem for the Java Platform. There are a number of JBI-based Implementations; Project OpenESB is the one that we are ensuring works with GlassFish.

Stay tuned for more news on OpenESB and GlassFish, but let us know of other ESB implementations that work with GlassFish.