ICEfaces Water Cooler

JSF 2.0 Complete Reference, with JSF Portlet Appendix

2010-02-03T05:29:49-06:00

I'm pleased to announce the new JSF 2.0 Complete Reference book by Ed Burns and Chris Schalk, published by McGraw-Hill. During the planning stages, Ed asked me to be a contributing author and help bring the first edition of the book up-to-date with JSF 2.0, and also to write a JSF Portlet Appendix.

As listed in the Table of Contents, Appendix A discusses the following Topics:

Overview of Portlet 1.0 and 2.0
- Portlet Lifecycle
- Portlet Modes
- Portlet Window States
- Portlet Preferences
- Inter-Portlet Communication
JSF Portlet Development
- JSF Portlet Bridges
- JSF Portlet View Handlers
- JSF ExernalContext and the Portlet API
- JSF and Portlet Preferences
- JSF and Inter-Portlet Communication
ICEfaces Portlet Development
- ICEfaces Ajax with Partial Submit
- ICEfaces Direct-to-DOM RenderKit
- The ice:portlet Tag
- ICEfaces 1.x Portlet Bridge
- ICEfaces 1.x D2DFaceletViewHandler
- ICEfaces 1.x and Portlet Window States
- ICEfaces Portlets and Concurrent DOM Views
- ICEfaces 1.x Extended Request Scope
- ICEfaces Ajax Push and Inter-Portlet Communication
- ICEfaces Themes and Portal Themes
- ICEfaces Themes and Liferay Themes
- ICEfaces Ajax Bridge and Liferay Portal
- ICEfaces Portlets and Liferay Request Attributes
PortletFaces
- Downloading PortletFaces
- PortletFacesContext
- PortletFaces Tags
- PortletFaces and Portlet Preferences
- PortletFaces and Expression Language Additions
- PortletFaces and Localization
- Liferay Language Portlet Integration
- Improved Integration Between Liferay and ICEfaces 1.x

This week (Feb 2nd to Feb 5th) Ed Burns & Chris Schalk will be helping to answer questions about the new book at JavaRanch. In addition, JavaRanch will be giving away a free copy of the book.

Finally I'd like to express my gratitude to ICEsoft, Mimacom, Liferay, and Triton for their generous support in making the JSF Portlet Appendix possible.

JSF 2.0 + ICEfaces 2.0 + Portlet 2.0 = The PortetFaces Bridge

2010-01-27T16:41:09-06:00

UPDATE#1: PortletFaces Bridge webinar took place on Thursday, Feb 11 2010 AD. Click here to view the PDF slideshow.

UPDATE#2: The source code is at Alpha1 status and can be checked out from SVN here:

I'm working on a new project called the PortletFaces Bridge which will enable the use of JSF 2.0 within Portlet 2.0 compliant portals like Liferay 5.x. The bridge implements a subset of the features available in JSR-329. Although the JSR-329 standard defines an API for a JSF 1.2 + Portlet 2.0 bridge, the PortletFaces Bridge is targeting JSF 2.0. Additionally, the bridge will facilitate usage of ICEfaces 2.0 within Liferay Portal.

Project Status as of January 27, 2010 AD:

I have a sample JSF 2.0 portlet developed that is using the new PortletFaces Bridge.
HTTP GET of portal page: bridge runs the portlet RENDER_PHASE, which runs the JSF lifecycle+renderResponse and the portlet renders fine in the browser.
HTTP POST after clicking h:commandButton: bridge runs the portlet ACTION_PHASE, which runs the JSF lifecycle. It then runs the portlet RENDER_PHASE, which runs the JSF renderResponse and the portlet renders fine in the browser.
RESOURCES: When using the new JSF 2.0 "resource" mechanism (like for downloading the "jsf.js" JavaScript file), the bridge correctly invokes the portlet RESOURCE_PHASE, which invokes the JSF 2.0 ResourceHandler and the contents of the requested resource are correctly delivered back to the browser.
AJAX: After tabbing-out of a field, the JSF 2.0 "jsf.js" JavaScript code correctly invokes the portlet RESOURCE_PHASE, which runs the JSF lifecycle+renderResponse, and correctly applies the DOM updates in the browser. Currently it uses the new JSF 2.0 <f:ajax /> tag to do Ajax requests. BTW I had to fix a problem in Mojarra to make this work -- I'm in contact with the Mojarra team and they're working on fixing it for the upcoming 2.0.3 release.
What's left: There's a bunch of little things -- loose ends that need to be coded up. Stuff like:
- Testing of ICEfaces 2.0 WITHOUT the <f:ajax /> tag
- Testing of ICEfaces 2.0 components (compatibility components)
- Testing of ICEfaces 2.0 Ajax Push
- After navigation-rules fire, need to compute the next JSF viewId to render
- Detecting portlet mode changes (VIEW MODE, EDIT MODE, HELP MODE)

The goal is to have an Alpha version ready for use in time for the webinar on Thursday, Feb 11 2010 AD. The bridge will be be an open source project and be available for download from the http://www.portletfaces.org website.

Which version of ICEfaces?

2010-01-27T11:15:36-06:00

People have been asking which ICEfaces version they should use. There are three main choices, and the full source code is available in each case:

ICEfaces-EE 1.8.2: You are using ICEfaces in production. You need rapid response to support issues, may have a highly available cluster on a commercial application server, and benefit from an extended component suite and testing resources. We are truly grateful to our subscribers and recognize that they are what makes ICEfaces possible.
ICEfaces 1.8.2: You are using ICEfaces to freely develop an application with rich JSF components and revolutionary Ajax Push features. You are supported by the very active ICEfaces community and generally deploy a single application to an open source server.
ICEfaces 2.0 A2: You are ready to benefit from JSF 2.0. We recommend that everyone begin with a prototype now and send in their feedback during the alpha phase.

Why not just support ICEfaces 1.8 on JSF 2.0? In theory, this is possible, but it further increases the test matrix for ICEfaces 1.8 and cannot provide the major architectural simplifications obtained by building ICEfaces 2.0 purely on JSF 2.0. But in essence, the compatibility library in ICEfaces 2.0 (icefaces-compat.jar) is ICEfaces 1.8 on JSF 2.0.

ICEfaces 2.0 Alpha2 is now available

2010-01-22T19:31:26-06:00

ICEfaces 2.0 has reached Alpha 2 and is now available for download. If you're using JSF (or are curious about JSF), now is the time to try JSF 2.0: Facelets is standard, providing an advanced yet easy to use page and component definition language, the new standard View Scope correctly handles multiple windows and tabs, and standard annotations have eliminated tedious XML configuration. ICEfaces 2.0 provides a rich set of components and transparently adds Ajax to the JSF rendering process, giving you an Ajax application without writing a single line of JavaScript or manually adding any Ajax tags. ICEfaces also provides the easiest to use and most powerful Ajax Push API of any web framework in any language (a grand claim? please comment if you disagree).

ICEfaces 2.0 Alpha 1 was a technology preview, intended for experimentation. ICEfaces 2.0 Alpha 2 might have a few known issues (FileUpload is not available, and you may see a few exceptions) but is ready for general prototyping and application development. Porting the ICEfaces 1.8 sample applications was very easy (a couple of hours in each case), so please give us feedback on your porting experience so that we can enhance the compatibility layer and add porting tips to the wiki documentation.

For this release, the most extensive work has gone into the compatibility layer (providing the ICEfaces 1.8 components on JSF 2.0 ... even for Internet Explorer 6) and the standalone Ajax Push library (which is not quite ready to use standalone; more on that in the coming weeks). It's time to begin moving your ICEfaces 1.8 application to ICEfaces 2.0. We look forward to seeing you on the forums.

GlassFish v3 and ICEfaces 2.0

2009-12-10T18:18:35-06:00

GlassFish v3 is now available.

GlassFish v3 is an ideal server for ICEfaces 2.0:

JavaServer Faces 2.0 is included in GlassFish, so the only .jar files necessary in an ICEfaces application are icefaces.jar and icepush.jar (this results in the new ICEfaces auction demo being only 400k)
Servlet 3.0 is available to support highly scalable Ajax Push applications through asynchronous request processing (javax.servlet.AsyncContext)
JMS supports the communication necessary to coordinate Ajax Push updates between multiple applications on the same server or within a cluster (to get JMS you must download the full version, not the "Web Profile").

To get started with GlassFish v3 and ICEfaces 2.0:

Download GlassFish v3 from http://glassfish.dev.java.net
Check out the latest ICEfaces 2.0 http://anonsvn.icefaces.org/repo/icefaces/scratchpads/glimmer
Build ICEfaces with ant world to build .war files for the default JavaEE 6 target (without jsf-api.jar and jsf-impl.jar as already provided by GlassFish)
Or download an ICEfaces 2.0 Alpha binary and use the pre-built auction.war
Copy /samples/auction/build/dist/auction.war to glassfishv3/glassfish/domains/domain1/autodeploy/

Please try it out and let us know what features you are hoping for in ICEfaces 2.0 (it's only in Alpha, so things are still very flexible).

High-Availability Ajax Push Deployments - An Industry First For ICEfaces EE

2009-12-03T10:50:00-06:00

Anyone that has witnessed the Google Wave demo knows that real-time, collaborative web applications are upon us. Web-based Ajax Push is fundamental to these types of applications, and has also been fundamental to ICEfaces since the very first release of the framework. Google's excellent adventure aside, we see Ajax Push moving out of the early adopter stage and into serious enterprise deployments with stringent scalability and availability requirements.

ICEfaces is keeping pace with these revolutionary deployment requirements by introducing industry-first capabilities in the Enterprise Push Server (EPS), which is now available in the newly-released ICEfaces Enterprise Edition 1.8.2. You can read more about EPS here, or if you are a supported customer a more detailed description is available in the ICEpack wiki here.

There are a few solutions in industry today that deliver Ajax Push capabilities, and most of them, including ICEfaces, relying on the long-polling technique to deliver asynchronous push updates to the browser. This technique requires an open connection to be held in anticipation of push events, which works fine if you only have a single view onto a single web application, as only one push connection is required. A major problem manifests itself though when you open multiple browser views onto the same web application, have multiple push-enabled applications deployed within the same domain, or have multiple push-enabled portlets in the same page. It is not feasible for each view to maintain its own push connection, as this will exceed the browsers connection limit, so it is necessary to share the push connection among the views. ICEfaces solves this problem with the client-side Ajax Bridge performing connection sharing between the browser views, and the Push Server managing a single blocking connection at the server for each browser client. No other Ajax Push technology offering provides a comprehensive and transparent mechanism for connection sharing.

Returning our attention now to enterprise-grade, clustered, high-availability deployments, we see the push connection management problem compound itself, as now we need to support load sharing and fail over of push connections. This is the domain of the Enterprise Push Server, which delivers those precise capabilities, as illustrated in the deployment architecture diagram below.

The architecture leverages standard Java Enterprise clustered deployment capabilities using front-end load sharing with session affinity, and session replication for application fail over support. Standard load sharing techniques are also used to distribute push connections among multiple EPS instances in the cluster, using affinity based on an EPSID instead of a SESSIONID. Enterprise Push Servers track and ensure the delivery of updates to clients and communicate that information amongst themselves, via JMS, so that any EPS node is capable of responding to any client. When a node in the cluster goes down, push connections migrate to other viable nodes, and the EPS instances there take over connection management responsibilities. The failure condition is communicated to the client's Ajax Bridge, which reloads the page to synchronize state between the client and server. Beyond the page reload, the user experience is uninterrupted.

These capabilities are yet another industry first for ICEfaces, and are available exclusively in the ICEfaces Enterprise Edition, including support for the following application servers.

Vendor	Product	Version
Apache	Tomcat (w/ Apache ActiveMQ 5.1)	6.0
JBoss Inc.	JBoss Application Server	4.2.x
IBM	Websphere Application Server	6.1
Oracle	WebLogic Server	10.3.1

So as collaborative applications become the mainstay of your Enterprise, you can rely on ICEfaces and the Enterprise Push Server to deliver highly-scalable and highly-available deployments of mission-critical applications.

What's new in JSF 2.0 webinar online

2009-11-13T13:07:17-06:00

In case you missed the webinar that Kito and I gave live last Wednesday, you can now view an archived version of the What's New in JSF 2 presentation.

Also, don't forget to sign up for the JSF Summit (December 1-4 in Orlando, FL) . We can only tell you so much about JSF 2.0 in a one hour webinar; at this conference, you can learn about how to use the new features in depth and meet the experts who developed the specification. JSF 2.0 is now available, so the JSF Summit is really the launch. Dan Allen has also started the idea of a JSF logo contest, so be sure to bring your logo ideas.

What's new in JSF 2.0?

2009-11-02T13:42:34-06:00

Kito Mann and I will be giving a webinar this Wednesday, Nov 4 on JavaServer Faces 2.0. WebMC has been ported to JSF 2.0, so I'll be using a few lessons from that easy porting exercise to explain some of the differences between JSF 1.2 and JSF 2.0. To prepare for the webinar, please download the ICEfaces 2.0 Alpha and JSF 2.0 and have your questions and comments ready.

Now that JSF 2.0 is ready, when do you plan on using it in production? As a start, we should really deploy some of the ICEfaces 2.0 demos on ICEfaces.org.

ICEfaces 2.0 - Alpha 1 is out!

2009-10-30T15:52:48-05:00

I'm very pleased to announce that ICEfaces 2.0 - Alpha 1 is now available for download.

This inaugural development milestone release of ICEfaces 2.0 provides the fundamental capability of running the next-generation ICEfaces core on the Mojarra JSF 2.0.1 runtime. You can plug the icefaces.jar into your existing JSF2 application and immediately receive some of the benefits of ICEfaces Direct-to-Dom rendering, such as providing incremental page updates without the need to specify the JSF 2 "f:ajax" tag. A sample application is included demonstrating ICEfaces 2 with JSF 2 ("h:") standard components, and Ajax Push.

Also included in this release is the initial implementation of the ICEfaces 1.x compatibility libraries, along with sample applications that demonstrate this capability. The ICEfaces 1.x compatibility libraries are used to readily port your existing JSF 1.2 / ICEfaces 1.8 applications to JSF 2.0 / ICEfaces 2.

See the Release Notes for all the details.

We are planning to have another significant ICEfaces 2 milestone release, featuring the beginnings of our all-new ICEfaces 2 component suite, before the end of this year, so stay tuned!

Countdown to ICEfaces 2.0 - Alpha 1

2009-10-27T18:38:00-05:00

JSF 2, and soon ICEfaces too!

As you may know the Sun "Mojarra" JSF 2.0 GA release has just occurred. With the JSF 2.0 runtime in place we're now in the final days of preparation for the corresponding ICEfaces 2.0 Alpha 1 release.

ICEfaces 2.0 represents a truly next-generation Ajax / JSF / Push framework development. We're using everything we've learned from the ICEfaces community throughout the ICEfaces 1.x release cycle to rationalize the ICEfaces feature-set, keeping the stuff that worked well and finding better solutions for everything else. Certainly the new capabilities in JSF 2.0 provide a strong starting point, but there is a lot of work going on now to make ICEfaces 2.0 meet and exceed your expectations. Our goal is nothing less than to make ICEfaces 2.0 the most productive, easy-to-use, and powerful JSF framework anywhere.

Notables:

Represents a "re-envisioning" of ICEfaces in terms of key features, architecture, and implementation.
Based-on the JSF 2 specification and runtimes, will require JDK 1.5+
Is the ICEfaces platform for new feature development and emerging technologies support and integration.
Will (eventually) include an all new ICEfaces Component Suite with a consistently improved level of component richness, performance, accessibility, and extensibility.
Unfortunately, the price of great progress in this case is that ICEfaces 2 is not directly backwards compatible with ICEfaces 1.x applications. However, we are well into development of a compatibility library and porting strategy that will ease migration of existing applications, including support for existing custom components, to ICEfaces 2.0.

Ted has more thoughts on JSF 2 and ICEfaces 2.0 here.

...stay tuned for more details on the ICEfaces 2.0 - Alpha 1 release.

JSF 2.0 with ICEfaces 2.0 Alpha

2009-10-27T18:14:29-05:00

ICEfaces 2.0 Alpha is nearing release. Here's what you can expect:

Current ICEfaces 1.8 components supported via icefaces-comps-compat.jar
Some minor page changes to port your application (such as to use standard h:head and h:body tags)
Ajax features added automatically via Direct-to-DOM rendering (no f:ajax tag required)
org.icefaces.* packaging (such as org.icefaces.application.PushRenderer)
JSF 2.0.1 and JDK 1.5 are required

Internally, the changes are very significant, and many simplifications were possible within ICEfaces through use of the standard JSF Ajax features (such as PartialViewContext and jsf.js). For the application developer, though, the major changes at this point lie with JSF 2.0 itself (you can expect to add significant features to your applications once the new ICEfaces 2.0 components become available; also, if you are using component APIs directly, you should expect larger changes ). For instance, two significant benefits from JSF 2.0 are that Facelets is now standard, and that you have the option to use annotations rather than faces-config.xml for managed bean definitions.

We have some webinars and talks lined up to get you ready for ICEfaces 2.0 and JSF 2.0. When do you plan on adopting JSF 2.0? If you had concerns with JSF 1.2, have they been addressed? What would you like to see in ICEfaces 2.0? Let us know; it's still early in the ICEfaces 2.0 development cycle, and we're very interested in incorporating your feedback.

PortletFaces Project Announcement and Webinar

2009-10-27T13:31:32-05:00

I'm pleased to announce that the PortletFaces project has now been formally established and can be found here: http://www.portletfaces.org

An ICEsoft+Mimacom webinar has been scheduled for Thursday October 29, 2009:

4PM - 5PM CET
11AM - 12PM EDT
8AM - 9AM PDT

Here's the registration link: https://www1.gotomeeting.com/register/741441337

I'll be conducting the webinar along with Micha Kiener of Mimacom, sponsor of the Edoras Framework.

The goal the PortletFaces project is to make it easier to develop JSF portlets that run within Liferay Portal. The project contains a wealth of features that expose the standard features of the Portlet 2.0 API and vendor-specific features of Liferay in a way that is natural to JSF development. It also provides improved integration between Liferay and ICEfaces 1.x portlets.

The beginnings of PortletFaces can be traced back to a forum post made by community member Joel Kozikowski back in May of 2007. Joel donated his code to Liferay and we began to work on the project together under Liferay incubation. Since then, PortletFaces has been adopted by Mimacom AG and is a sub-project of the edoras framework.

I'd like to personally thank Joel and the other contributors for their valuable additions to PortletFaces:

Micha Kiener
Atul Patel
Ed Shin
Stefan Niederhauser

Also my personal thanks to Liferay for sponsoring PortletFaces during incubation, ICEsoft for all the terrific support, and thanks to Mimacom for adopting the project.

Finally, I'd like to thank Triton's Steve Groninga for coming up with the PortletFaces project logo.

Documentation for PortletFaces can be found here: http://www.portletfaces.org/documentation

Ajax Push/Comet Panel and JSFSummit

2009-10-16T17:34:15-05:00

If you're near the Google campus this Wednesday, Oct 21, please stop in for the Ajax Push Panel:The Chronicles of Web Standard Prince Comet: Next Wave of Comet. I'll be there along with Alex Russell, Michael Carter, Greg Wilkins, and Dylan Schiemann. It should be a good opportunity to discuss the impact of Google Wave and Cloud Computing on push technologies. Should Google support Servlet 3.0 in the Google App Engine, or should they force people to use proprietary technologies? Should ICEfaces Ajax Push be split out into a separate push server, available with no dependency on JSF?

Then, in November, you should head to the JSFSummit in Orlando. This is the leading North American conference for JavaServer Faces, and is the perfect place to ramp up on JSF 2.0.

ICEfaces with Google Translate Tutorial

2009-09-09T12:03:38-05:00

Oleg Tikhonov has posted a developerWorks tutorial on ICEfaces with Google translate. It's a good introduction to ICEfaces, IBM WebSphere Community Edition, the Eclipse WTP tools for JSF, and the Google translate API. The google translate API looks very easy to use :


translatedText = Translate.translate(text, originalLanguage, translatedLanguage);

The next interesting thing would be to combine translation with push (for instance, a chat server with translation capability).

ILOG and ICEfaces webinar

2009-09-08T11:51:28-05:00

A WebEx recording of the joint ILOG/ICEfaces presentation is available.

Data visualization driven through Ajax Push allows better business decisions to be made in a real time connected enterprise. This web seminar explains the importance of visualization and how it can be implemented in web applications with a combination open source and commercial technologies. Stepping through the code of a multi-user shipping/receiving application, attendees will learn how to include visualization in their applications and how to apply push to enable multi-user interaction and collaboration. Topics will include development and deployment considerations as well as a behind-the-scenes look at techniques used internally by the ILOG and ICEfaces technologies.