glassfish-webtier

IE, Memory Management, and You

Fri, 13 Nov 2009 12:59:01 -0800

In a recent blog, commenters took me to task for a perceived IE 6 memory leak. It wasn't actually there (they were wrong), but in attempting to prove myself right, I found a couple of memory leaks under IE in JSF's Ajax support. Since I just spent a week learning how all this functioned, I thought I'd set it down so that others could learn from my efforts.

Now, none of the information that I'll present here is new - it's been discussed among Ajax programmers for at least the last 4 years. If you're a web guru, it's likely that you're not going to learn anything new here (thought I'd welcome any additional information and corrections). But at least a couple of the points I'll illustrate below are either poorly communicated or misunderstood. I'll include a number of links at the end of this article. There are also very significant differences between IE 8 (which mostly works), IE 7 (which is bad), and IE 6 (which is just awful). I'll try to point out the differences as they matter for each.

Tools

First - use the right tool for the job: In order to spot leaks, you'll need to download a tool that can detect them. By all accounts, sIEve is the way to go. It uses IE itself, and introspects to get it's data. The UI is pretty primitive, but I can't recommend it enough - it's truely invaluable. Since it uses IE for it's work, you'll need to run it on a machine that has IE6 installed - presumably in a VM. You'll also want to have it running on a machine that has IE 7 and IE 8 as well, just to be sure. XP fits nicely on a VM that runs on my Mac, and this is how I use it.

Cyclic Leak

Now that that's out of the way, it's time to talk about the very worst of the memory leaks in IE - the dreaded cyclic reference, which the commenters thought that I'd committed. Under certain conditions, IE 6 will "leak" DOM nodes, retaining them, and the javascript objects that point to them, until the browser is either shut down, or crashes entirely due to lack of memory. Ugh! To understand how this happens, you really only need to know two things:

IE 6 (and 7!) reportedly has very primitive garbage collection using reference counting
There are two memory spaces in IE, one for JavaScript, and the other for the DOM, and they don't communicate well.

What could go wrong? Well, lots. The commenters thought that the rule was: A leak will occur if any reference is made in JavaScript to an element that isn't eventually set to null. That's close, but not quite correct. The real rule is: A leak will occur if the JavaScript code contains any reference to the DOM that isn't released in some way, either by going out of scope or being explicitly unset.

When IE 6 sees a JavaScript variable that is pointing to something in the DOM (typically, an element or node), it will record that reference, and not collect it - even when you surf over to a new page. And the DOM won't be collected, since there's a reference to it from JavaScript. These two objects, and all the stuff that references them, will stick around until shutdown. In IE 7, the geniuses at Microsoft saw the bug, and said "Hey, I know how to fix that, let's garbage collect everything when we leave the page.". Nice improvement, but it still doesn't fix the bug, since if you're developing a page that is designed to be used for a long period of time (like many page-as-application apps are now), it'll still crash the browser. Apparently, they saw the error of their ways eventually, since this behavior is no longer present in IE8. (All this is confirmed by my testing with sIEve.)

So, in the example that had in my previous blog, there was no memory leak, because the variable that pointed to the element eventually went out of scope. So - how to you create variables that don't go out of scope? The easiest way is to put them in an object - this was the leak that I eventually found in JSF. The fix there was to null out the object manually. But there's another, more insidious way to create an object - create a closure. That creates a function object implicitly under the window object, and that will never go out of scope. But the key thing to remember is that you need to be aware of when things go out of scope when coding in IE, and act accordingly.

But wait! There's more

If that was the only problem, life would have been fairly easy for me the last week. But that's not the only bug that the Web Wizards of Redmond chose to deliver to their unsuspecting consumers. There's another bug in IE (again, only in IE 6 and 7 - IE 8 appears to have fixed it per my testing), which also leaks DOM nodes that aren't cleaned up until you leave the page. Apparently, when the IE DOM receives a call from the removeChild or replaceChild functions, it doesn't actually, err, remove the nodes. It just leaves them there, hanging around the DOM like party guests that don't have the sense to leave after the host has started handing out coats. While these nodes will eventually be cleaned up when the user leaves the page, this still causes problems for page-as-app programs, as in the cyclic leak for IE 7, above. While the removeChild call is fairly notorious for this, I had to find out about replaceChild with my own testing (though I did find a few obscure references once I went looking for it).

That means that instead of saying node.parentNode.replaceChild(newNode, node), you instead should say something like: node.parentNode.insertBefore(newNode, node); deleteNode(node); (with an appropriate if statement for isIE(), and a deleteNode function that doesn't use removeChild). And instead of saying node.parentNode.removeChild(node); you instead are reduced to coding something like: node.outerHTML = ''; (again, with browser check). Except that when you combine that with IE's horrible problems with manipulating tables, it may fail. So instead, you're probably better off with something like this:

 var temp = document.createElement('div'); try { temp.appendChild(node.parentNode.removeChild(node)); temp.innerHTML = ""; // Prevent leak in IE } catch (e) { // at least we tried } deleteNode(temp);

Again, possibly with an isIE() check.

Hopefully you found this description of IE's Memory "Management" useful. Here's a few of the links that I used for research, that I found the most helpful.

sIEve - the tool you should already have.
Quirks blog link roundup of memory leak info.
Microsoft MSDN article on the topic. Useful, even if it insultingly implies that it's your fault the browser is leaking.

As always, I look forward to any comments. Especially about this topic - I'm far from expert in this area.

TOTD #113: JavaFX front-end for GlassFish v3 Administration - Using REST interface

arungupta — Tue, 10 Nov 2009 20:15:33 -0800

GlassFish v3 provides a REST interface to management and monitoring information as discussed in TOTD #96. As mentioned in that blog "the REST interface is a lower level API that enables toolkit developers and IT administrators to write their custom scripts/clients using language of their choice". This blog introduces a tool that uses the REST API to provide management and monitoring of GlassFish v3 and is written using JavaFX.

This tool is only a proof-of-concept that demonstrates that GlassFish v3 REST interface is functionally very rich and can indeed be used to write third-party administration tools. The tool uses a subset of the REST interface and exposes only a limited amount of management and monitoring capabilities otherwise exposed. After all this is a proof-of-concept :-)

A screencast of this tool in action along with a downloadable JNLP version will soon be available. For now, here is a snapshot of the main window of this tool:

The main screen allows you to enter a URL for the GlassFish administration. Then the GlassFish instance can be stopped/restarted from the main window using the buttons on top right. There is an animation at the bottom of the screen where the glassfish is swimming in the ocean and is directly related to the state of server running in the background. If the server is running, the animation works. If the server is not running then the animation stops as well.

The main screen has three main buttons:

"List Applications" - list all the applications deployed on the running instance
"Show Monitoring Levels" - show/Update all the monitoring levels
"Server Stats" - show statistics of the running server

Clicking on "List Applications" shows the list of applications deployed on this particular instance. Here is how a snapshot looks like for an instance running on my localhost at port 4848:

As shown in the screen, it shows a radio-bulleted list of all the applications. Each bullet is also accompanied by an image indicating the type of application - Web or Rails for now. Select the application and click on "Monitor" button to monitor that particular application. The REST API exposes a vast amount of monitoring data but a subset of monitoring data is displayed for Web and Rails application for now. Here is a snapshot of the monitoring data published for a Web application:

As evident by the list of engines, this web application has EJBs bundled as well. It also shows total number of Servlets/JSPs loaded, number of requests made to this web application and some other monitoring data.

Here is a snapshot of the monitoring data published for a Rails application:

It shows number of JRuby runtimes configured for the application, number of requests sent to the application, number of responses with different HTTP access codes and some other data.

The monitoring levels of different containers can be easily updated by clicking on "Show Monitoring Levels" as shown below:

And finally some server statistics are shown by clicking on "Server Stats" as shown below:

It shows when the server was started, host/port information, version and finally how long the server has been running for. The dials are an animation that shows the server up time.

Here are other related JavaFX and GlassFish related blogs published earlier:

How are you going to use the REST interface exposed by GlassFish v3 in your environment ?

Are you using JavaFX with GlassFish together in any way ?

Servlet 3.0 Asynchronous API or Atmosphere? Easy decision!

Fri, 06 Nov 2009 09:38:21 -0800

One the comment I'm getting about Atmosphere is why should I use the framework instead of waiting for Servlet 3.0 Async API. Well, it simple: much simpler, works with any existing Java WebServer (including Google App Engine!), and will auto-detect the Servlet 3.0 Async API if you deploy your application on a WebServer that support it.

To make a fair comparison, let's write the hello world of Comet, a Chat application and compare the server side code. Without technical details, let's just drop the entire server code. First, the Servlet 3.0 version (can probably be optimized a little):

 1 package web.servlet.async_request_war; 2 3 import java.io.IOException; 4 import java.io.PrintWriter; 5 import java.util.Queue; 6 import java.util.concurrent.ConcurrentLinkedQueue; 7 import java.util.concurrent.BlockingQueue; 8 import java.util.concurrent.LinkedBlockingQueue; 9 10 import javax.servlet.AsyncContext; 11 import javax.servlet.AsyncEvent; 12 import javax.servlet.AsyncListener; 13 import javax.servlet.ServletConfig; 14 import javax.servlet.ServletException; 15 import javax.servlet.annotation.WebServlet; 16 import javax.servlet.http.HttpServlet; 17 import javax.servlet.http.HttpServletRequest; 18 import javax.servlet.http.HttpServletResponse; 19 20 @WebServlet(urlPatterns = {"/chat"}, asyncSupported = true) 21 public class AjaxCometServlet extends HttpServlet { 22 23 private static final Queue<AsyncContext> queue = new ConcurrentLinkedQueue<AsyncContext>(); 24 private static final BlockingQueue<String> messageQueue = new LinkedBlockingQueue<String>(); 25 private static final String BEGIN_SCRIPT_TAG = "<script type='text/javascript'>\n"; 26 private static final String END_SCRIPT_TAG = "</script>\n"; 27 private static final long serialVersionUID = -2919167206889576860L; 28 29 private Thread notifierThread = null; 30 31 @Override 32 public void init(ServletConfig config) throws ServletException { 33 Runnable notifierRunnable = new Runnable() { 34 public void run() { 35 boolean done = false; 36 while (!done) { 37 String cMessage = null; 38 try { 39 cMessage = messageQueue.take(); 40 for (AsyncContext ac : queue) { 41 try { 42 PrintWriter acWriter = ac.getResponse().getWriter(); 43 acWriter.println(cMessage); 44 acWriter.flush(); 45 } catch(IOException ex) { 46 System.out.println(ex); 47 queue.remove(ac); 48 } 49 } 50 } catch(InterruptedException iex) { 51 done = true; 52 System.out.println(iex); 53 } 54 } 55 } 56 }; 57 notifierThread = new Thread(notifierRunnable); 58 notifierThread.start(); 59 } 60 61 @Override 62 protected void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException { 63 res.setContentType("text/html"); 64 res.setHeader("Cache-Control", "private"); 65 res.setHeader("Pragma", "no-cache"); 66 67 PrintWriter writer = res.getWriter(); 68 // for IE 69 writer.println("<!-- Comet is a programming technique that enables web servers to send data to the client without having any need for the client to request it. -->\ n"); 70 writer.flush(); 71 72 req.setAsyncTimeout(10 * 60 * 1000); 73 final AsyncContext ac = req.startAsync(); 74 queue.add(ac); 75 req.addAsyncListener(new AsyncListener() { 76 public void onComplete(AsyncEvent event) throws IOException { 77 queue.remove(ac); 78 } 79 80 public void onTimeout(AsyncEvent event) throws IOException { 81 queue.remove(ac); 82 } 83 }); 84 } 85 86 @Override 87 @SuppressWarnings("unchecked") 88 protected void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException { 89 res.setContentType("text/plain"); 90 res.setHeader("Cache-Control", "private"); 91 res.setHeader("Pragma", "no-cache"); 92 93 req.setCharacterEncoding("UTF-8"); 94 String action = req.getParameter("action"); 95 String name = req.getParameter("name"); 96 97 if ("login".equals(action)) { 98 String cMessage = BEGIN_SCRIPT_TAG + toJsonp("System Message", name + " has joined.") + END_SCRIPT_TAG; 99 notify(cMessage);
100 101 res.getWriter().println("success");
102 } else if ("post".equals(action)) {
103 String message = req.getParameter("message");
104 String cMessage = BEGIN_SCRIPT_TAG + toJsonp(name, message) + END_SCRIPT_TAG;
105 notify(cMessage);
106 107 res.getWriter().println("success");
108 } else {
109 res.sendError(422, "Unprocessable Entity");
110 }
111 }
112 113 @Override
114 public void destroy() {
115 queue.clear();
116 notifierThread.interrupt();
117 }
118 119 private void notify(String cMessage) throws IOException {
120 try {
121 messageQueue.put(cMessage);
122 } catch(Exception ex) {
123 throw new IOException(ex);
124 }
125 }
126 127 private String escape(String orig) {
128 StringBuffer buffer = new StringBuffer(orig.length());
129 130 for (int i = 0; i < orig.length(); i++) {
131 char c = orig.charAt(i);
132 switch (c) {
133 case '\b':
134 buffer.append("\\b");
135 break;
136 case '\f':
137 buffer.append("\\f");
138 break;
139 case '\n':
140 buffer.append("<br />");
141 break;
142 case '\r':
143 // ignore
144 break;
145 case '\t':
146 buffer.append("\\t");
147 break;
148 case '\'':
149 buffer.append("\\'");
150 break;
151 case '\"':
152 buffer.append("\\\"");
153 break;
154 case '\\':
155 buffer.append("\\\\");
156 break;
157 case '<':
158 buffer.append("<");
159 break;
160 case '>':
161 buffer.append(">");
162 break;
163 case '&':
164 buffer.append("&");
165 break;
166 default:
167 buffer.append(c);
168 }
169 }
170 171 return buffer.toString();
172 }
173 174 private String toJsonp(String name, String message) {
175 return "window.parent.app.update({ name: \"" + escape(name) + "\", message: \"" + escape(message) + "\" });\n";
176 }
177 }

OK now with Atmosphere , the same code consist of:

 1 package org.atmosphere.samples.chat.resources; 2 3 import javax.ws.rs.Consumes; 4 import javax.ws.rs.GET; 5 import javax.ws.rs.POST; 6 import javax.ws.rs.Path; 7 import javax.ws.rs.Produces; 8 import javax.ws.rs.WebApplicationException; 9 import javax.ws.rs.core.MultivaluedMap; 10 import org.atmosphere.annotation.Broadcast; 11 import org.atmosphere.annotation.Schedule; 12 import org.atmosphere.annotation.Suspend; 13 import org.atmosphere.util.XSSHtmlFilter; 14 15 @Path("/") 16 public class ResourceChat { 17  18 @Suspend 19 @GET 20 @Produces("text/html;charset=ISO-8859-1") 21 public String suspend() { 22 return ""; 23 } 24  25 @Broadcast({XSSHtmlFilter.class, JsonpFilter.class}) 26 @Consumes("application/x-www-form-urlencoded") 27 @POST 28 @Produces("text/html;charset=ISO-8859-1") 29 public String publishMessage(MultivaluedMap form) { 30 String action = form.getFirst("action"); 31 String name = form.getFirst("name"); 32 33 if ("login".equals(action)) { 34 return ("System Message" + "__" + name + " has joined."); 35 } else if ("post".equals(action)) { 36 return name + "__" + form.getFirst("message"); 37 } else { 38 throw new WebApplicationException(422); 39 } 40 } 41 }

OK so what's the deal? What's makes Atmosphere so easy? The Servlet 3.0 new Async API offers:

Method to suspend a response, HttpServletRequest.startAsync()
Method to resume a response: AsyncContext.complete()

Atmosphere offers:

Annotation to suspend: @Suspend
Annotation or resume: @Resume
Annotation to broadcast (or push) events to the set of suspended responses: @Broadcast
Annotation to filter and serialize broadcasted events using BroadcasterFilter (XSSHtmlFilter.class, JsonpFilter.class)
Build it support for all browser implementation incompatible implementation (ex: no need to output comments like in the Servlet 3.0 sample (line 69)). Atmosphere will workaround all those issues for you.

With Servlet 3.0 Async API, the missing part is how you share information with suspended responses. In the current chat sample, you need to creates your own Thread/Queue in order to broadcast events to your set of suspended responses (line 32 to 56). This is not a big deal, but you will need to do something like that for all your Servlet 3.0 Async based applications...or use a Framework that do it for you!.

Still not convinced? Well, you can write your Atmosphere applications today and not have to wait for Servlet.3.0 implementation (OK easy plug for my other project: GlassFish v3 supports it pretty well!). Why? Atmosphere always auto-detected the best asynchronous API when you deploy your application. It always try first to look up the 3.0 Async API. If it fails, it will try to find WebServer's native API like Grizzly Comet (GlassFish), CometProcessor (Tomcat), Continuation (Jetty), HttpEventServlet (JBossWeb), AsyncServlet (WebLogic), Google App Engine (Google). Finally, it will fallback to use a blocking I/O Thread to emulate support for asynchronous events.

But you don't want to use Java? Fine, try the Atmosphere Grails Plug In, or Atmosphere in PrimesFaces if you like JSF, or use Scala:

 1 package org.atmosphere.samples.scala.chat 2 3 import javax.ws.rs.{GET, POST, Path, Produces, WebApplicationException, Consumes} 4 import javax.ws.rs.core.MultivaluedMap 5 import org.atmosphere.annotation.{Broadcast, Suspend} 6 import org.atmosphere.util.XSSHtmlFilter 7 8 @Path("/chat") 9 class Chat { 10 11 @Suspend 12 @GET 13 @Produces(Array("text/html;charset=ISO-8859-1")) 14 def suspend() = { 15 "" 16 } 17 18 @Broadcast(Array(classOf[XSSHtmlFilter],classOf[JsonpFilter])) 19 @Consumes(Array("application/x-www-form-urlencoded")) 20 @POST 21 @Produces(Array("text/html;charset=ISO-8859-1")) 22 def publishMessage(form: MultivaluedMap[String, String]) = { 23 val action = form.getFirst("action") 24 val name = form.getFirst("name") 25 26 val result: String = if ("login".equals(action)) "System Message" + "__" + name + " has joined." 27 else if ("post".equals(action)) name + "__" + form.getFirst("message") 28 else throw new WebApplicationException(422) 29 30 result 31 } 32 33 34 }

Echec et Mat!

Now, I can understand you already have an existing application and just want to update it with suspend/resume/broadcast functionality, without having to re-write it completely. Fine, let's just use the Atmosphere's Meteor API:

 1 package org.atmosphere.samples.chat; 2 3 import java.io.IOException; 4 import java.util.LinkedList; 5 import java.util.List; 6 import javax.servlet.http.HttpServlet; 7 import javax.servlet.http.HttpServletRequest; 8 import javax.servlet.http.HttpServletResponse; 9 import org.atmosphere.cpr.BroadcastFilter; 10 import org.atmosphere.cpr.Meteor; 11 import org.atmosphere.util.XSSHtmlFilter; 12 13 public class MeteorChat extends HttpServlet { 14 15 private final List list; 16 17 public MeteorChat() { 18 list = new LinkedList (); 19 list.add(new XSSHtmlFilter()); 20 list.add(new JsonpFilter()); 21 } 22 23 @Override 24 public void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException {
 25 Meteor m = Meteor.build(req, list, null); 26 27 req.getSession().setAttribute("meteor", m); 28 29 res.setContentType("text/html;charset=ISO-8859-1"); 30 res.addHeader("Cache-Control", "private"); 31 res.addHeader("Pragma", "no-cache"); 32  33 m.suspend(-1); 34 m.broadcast(req.getServerName() + "__has suspended a connection from " + req.getRemoteAddr()); 35 } 36 37 public void doPost(HttpServletRequest req, HttpServletResponse res) throws IOException {
 38 Meteor m = (Meteor)req.getSession().getAttribute("meteor"); 39 res.setCharacterEncoding("UTF-8"); 40 String action = req.getParameterValues("action")[0]; 41 String name = req.getParameterValues("name")[0]; 42 43 if ("login".equals(action)) { 44 req.getSession().setAttribute("name", name); 45 m.broadcast("System Message from " + req.getServerName() + "__" + name + " has joined."); 46 res.getWriter().write("success"); 47 res.getWriter().flush(); 48 } else if ("post".equals(action)) { 49 String message = req.getParameterValues("message")[0]; 50 m.broadcast(name + "__" + message); 51 res.getWriter().write("success"); 52 res.getWriter().flush(); 53 } else { 54 res.setStatus(422); 55 56 res.getWriter().write("success"); 57 res.getWriter().flush(); 58 } 59 } 60 }

Servlet 3.0 Async API is Game Over! Finally I must admit that Servlet 3.0 Async API have asynchronous dispatcher you can use to forward request asynchronously:

 public void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException, ServletException { final AsyncContext ac = req.startAsync(); final String target = req.getParameter("target"); Timer asyncTimer = new Timer("AsyncTimer", true); asyncTimer.schedule( new TimerTask() { @Override public void run() { ac.dispatch(target); } }, 5000); }

With Atmosphere, the same code will works but your application will only works when deployed on Servlet 3.0 WebServer. Instead, you can implement the same functionality using Broadcast's delayed broadcast API and still have a portable application without limiting you with Servlet 3.0 Async API...that's something I will talk in my next blog!

For any questions or to download Atmosphere, go to our main site and use our Nabble forum (no subscription needed) or follow us on Twitter and tweet your questions there!

technorati: atmosphere framework rest comet jersey ajax push

New Hpricot Release

Nick Sieger — Fri, 06 Nov 2009 08:06:37 -0800

It’s with a modicum of fanfare and a cocktail of orange peel, maraschino, bitters, bourbon and vermouth that I announce the 0.8.2 release of Hpricot.

The angly thingies are just two martini glasses turned on their side, see? Pouring out hpricoty goodness for you. (I don’t know if _why imbibed alcoholic beverages but I feel the desire to raise a glass to him.)

This release is mostly a refresh; the previous release was way back in April. From the Git logs I can see that there were a few bug fixes since then. Otherwise, the main addition is a modern JRuby release, thanks to Ola Bini. (the previous was the 0.6 series). This does fix a fairly old, popular JRuby bug.

As for the future of Hpricot, it’s up to you. I know it’s still a trusty tool for many; I have no grand plans to change it. So if you encounter bugs and want to send patches, I’m happy to serve as your curator.

See you in Europe in November

Wed, 04 Nov 2009 09:58:03 -0800

I'm will be leaving Québec next week for talks at JFall, Paris JUG, Prague JUG and Devoxx. The talks will focus on Atmosphere and it's spin off (Grail Plug In, Akka, PrimesFaces) and a little bit of Grizzly's work-in-progress Servlet Container.

First, I will stop by Amsterdam November 11 and talk about Atmosphere at JFall 2009. Next I will stop by Paris JUG November 12 for an al-in-French talk on Atmosphere (I means pure French from Québec). Then on November 16 I will talk about Atmosphere at the Prague JUG. Finally I will be in Anwerp for Devoxx 2009, presenting Atmosphere and our new Grizzly Servlet Container which support new OSGi Http Service spec.

See you in EU!

technorati: atmosphere framework ajax push comet jersey grizzly

Leaving Sun

Frank Wierzbicki — Wed, 04 Nov 2009 06:05:00 -0800

I've always regarded working full time on Jython at Sun as a miraculous sabbatical that might come to an end at any moment. Sadly that time has come. I've worked with many amazing people and had a great time: Sun provided me with one of the greatest professional experiences I have had, for which I will always be grateful.

I'm very pleased with how far Jython has come during my tenure at Sun. Jython is now a modern version of Python, and has the momentum to continue its growth. A far larger group of developers than ever before contribute regularly, making Jython a very healthy project. Jython runs many more of the key frameworks and applications that are popular in the Python world. In the future we will be making Jython better, faster, and more complete. I started working on Jython long before I joined Sun, and I certainly plan be a part of Jython's future.

I am looking for a new opportunity, and am open to many possibilities. I have been working in software for more than twelve years, often in a lead role. I am well regarded in the Open Source world, where I have participated in and helped build communities. I have been the Jython project lead for almost five years. I am a committer on the Python project, and a member of the Python Software Foundation. I have done a wide variety of work in recent history: development and leadership work in Java and Python, from the abstract level of parsing Python source and compiling to Java bytecodes, to the more concrete work of web development. I am able to do work in any of these areas, on either a full time or consulting/contracting basis. My contact information can be found on my Google profile and my LinkedIn profile is a good summary of my credentials.

Writing a RESTful and Comet based PubSub application using Atmosphere in less than 10 lines

Tue, 03 Nov 2009 12:58:48 -0800

Writing a publisher/subscriber (PubSub) is quite simple with Atmosphere using the atmosphere-jersey module.

The main idea here is to use Comet for suspending the response when a client subscribe to a topic, and use REST for publishing messages to the those suspended responses. First, let’s bind our application to the root uri using the @path annotation

package org.atmosphere.samples.pubsub;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import org.atmosphere.annotation.Broadcast;
import org.atmosphere.annotation.Schedule;
import org.atmosphere.annotation.Suspend;
import org.atmosphere.cpr.Broadcaster;
import org.atmosphere.jersey.Broadcastable;

@Path("/") public class PubSub {

Next, let’s implement the subscribe operation by using the @Suspend and inject our Atmosphere’s Broadcaster using the @PathParam annotation:

 @Suspend
 @GET
 @Path("/{topic}")
 @Produces("text/plain;charset=ISO-8859-1")
 public Broadcastable subscribe(@PathParam("topic") Broadcaster topic) {
 return new Broadcastable("",topic);
 }

The code above will be invoked when we want to create a new topic (@Path("/{topic}"), we will return a Broadcastable instance which will tell Atmosphere to use the passed Broadcaster, who got injected using the @PathParam, when broadcasting {topic}. Finally, the underlying response will be suspended forever via @Suspend annotation. Next, let’s implement the publish operation:

 @GET
 @Path("/{topic}/{message}")
 @Produces("text/plain;charset=ISO-8859-1")
 @Broadcast
 public Broadcastable publish(@PathParam("topic") Broadcaster topic,
 @PathParam("message") String message){

 return new Broadcastable(message,topic);
 }

To publish, we just need to send a uri that takes the form of "/{topic}/{message}" as defined by @Path("/{topic}/{message}") and again, the Broadcaster we want to use to broadcast messagse will be injected based on the {topic} value. Finally, we just return a Broadcastable object and let Atmosphere broadcast the value to all suspended connections. That’s it! Now we can see it in action by doing:

Create a topic
curl http://localhost:8080/atmosphere-pubsub/myAtmosphereTopic
Publish to that topic
curl http://localhost:8080/atmosphere-pubsub/myAtmosphereTopic/Atmosphere_is_cool

The source for the entire sample can be viewed here. Really simple, is it?

For any questions or to download Atmosphere, go to our main site and use our Nabble forum (no subscription needed) or follow us on Twitter and tweet your questions there!

technorati: atmosphere framework rest comet jersey ajax push

Missed RubyConf? Attend Qcon's Ruby Track!

Charles Oliver Nutter — Sat, 31 Oct 2009 05:48:00 -0700

This year, RubyConf reportedly reduced their attendee cap to 250 people (Update: actually 450 people), after hosting a 500 to 600-person conference last year. As you can imagine, this meant a lot of people that wanted to attend were not able to get tickets. To complicate matters, the RubyConf registration site happened to go live during the middle of the night EU time, and by the time most Europeans woke up it was already sold out. What's a Rubyist to do?

Well there's another option. Working with Ryan Slobojan of InfoQ and the organizers of Qcon San Francisco, I'll be hosting a one-day Ruby track the day before RubyConf! Qcon's main conference runs Wednesday through Friday, with my track on Wednesday, November 18th.

And now the REALLY good news! Because we wanted this to be a fallback for folks that could not attend RubyConf, we realized that the full conference fee was simply too high (ranging from $1500 up). So to make it possible for people to attend just the one day Ruby track, you can register with the code "rubywednesday" to get a drastically reduced $350 one-day conference pass. And to sweeten the deal even more, you can pop over to other tracks and attend the keynotes that day. Yes Virginia, there is a Santa Claus!

Those of you attending RubyConf are also welcome to attend this one-day track as well; most of the presentations won't overlap. Here's the lineup, including a special opening presentation by Yukihiro Matsumoto himself!

10:20 - "The Many Facets of Ruby" track opening by me

Ruby has seen a dramatic growth in popularity over the last few years, and there are now many facets to the Ruby story - multiple implementations, game-changing web frameworks, and large-scale use in enterprise solutions. Join us as we explore many aspects of Ruby in today's world.

10:30 - "Why we love Ruby?" by Yukihiro Matsumoto

Why we love Ruby? I have asked myself this question repeatedly. In this presentation, I will disclose my answer as of 2009. The keyword is QWAN.

11:45 - "Basking in the Limelight" by Paul Pagel

Limelight is Ruby on the desktop. Build applications with multiple windows, or just one window. Take control of the desktop, or play nicely with the desktop. Create fun animated games, or productive business apps. Develop rich internet applications, or unwired apps to make you rich. Publish your apps on the internet, or keep them for you and your friends. Do all this, writing nothing but Ruby code, in Limelight.

13:45 - "You've Got Java in my Ruby" by Thomas Enebo

JRuby is now well-established as a popular alternative implementation of Ruby.But why would you want to use it? How can it help you? This talk will detail some of the more interesting differences and advantages of using JRuby. Expect to get a better understanding of how Java makes a faster and more stable Ruby as well as how you can leverage Java features as an extra set of tools for your project.

15:00 - "Rails 3" by Yehuda Katz

I don't have a full abstract for this, but it's what you might expect...an overview of why Rails 3 is really "growing up" the framework, making it more clearly componentized and easier to adapt to more complicated (dare I say "enterprise") applications in the future. In working with Yehuda I know he's also paid special attention to performance.. Rails 3 is going to be excellent.

16:30 - "Rails in the Large: How Agility Allows Us to Build One of the World's Biggest Rails Apps" by Neal Ford

While others have been debating whether Rails can scale to enterprise levels, we've been demonstrating it. ThoughtWorks is running one of the largest Rails projects in the world, for an Enterprise. This session discusses tactics, techniques, best practices, and other things we've learned from scaling rails development. I discuss infrastructure, testing, messaging, optimization, performance, and the results of lots of lessons learned, including killer rock-scissors-paper tricks to help you avoid babysitting the view tests!

I think it's going to an outstanding track, and I'd probably pay the $350 just to see Matz speak if I knew I wouldn't get another chance for a long time. Limelight looks like an outstanding way to build rich client apps using JRuby, and of course you know I like JRuby. Tom will show some of the latest advancements we've done in JRuby, including the ability to produce "real" Java classes at runtime for integrating with Java frameworks better. Rails 3 I've described above, but you really have to see Yehuda present it himself. And of course everyone would like to know how to scale Rails to the moon...Neal knows his stuff.

Here's the track page: The Many Facets of Ruby

And the full conference schedule for Wednesday.

And finally, the registration page (don't forget to use code "rubywednesday").

I really hope to see you all there, so you can get your Ruby conference fix this fall. Tell your friends and let me know if you have any questions!

Follow up on Servlet 3.0 Security Annotations

swchan — Thu, 29 Oct 2009 07:19:19 -0700

In May 2009, I discussed the Servlet 3.0 security annotations in one of my blogs, Servlet 3.0 Security Annotations. At that time, the annotations were defined similar to those in EJB. During the discussion in JSR 315 expert group, two issues were identified as follows:

In JSR 250, type level annotations only apply to methods declared in that class, not those inherited. This is an issue for servlets as they extend javax.servlet.http.HttpServlet.
The doGet method et al may not correspond to http method GET et al as the logic can be overrided in service method of the servlet.

Thanks to Ronald Monzilo for discussions in Servlet 3.0 security. The following is the update on Servlet 3.0 security annotations:

As in servlet 2.5, @DenyAll, @PermitAll, @RolesAllowed will not apply to servlets. @TransportProtected will not be added to JSR 250.
The following new annotations will be added to javax.servlet.annotation:
- ServletSecurity
- HttpConstraint
- HttpMethodConstraint
Note that @ServletSecurity is a type level annotation and the rests are used as parameters in @ServletSecurity.
With the above new annotations, one can resolve the issue mentioned above. In addition, it covers the new use case where one want to have security constraint for extended http methods only, for instance FOO.

In this blog, I will illustrate how those annotation work. For convenient of readers of my previous blogs, I will first illustrate the four scenarios mentioned in my previous blog, Servlet 3.0 Security Annotations with the new annotations. Then I have an additional example.

Example 1: For all Http Methods

@WebServlet("/myurl")
@ServletSecurity(@HttpConstraint(rolesAllowed={"javaee"}))
public class TestServlet extends HttpServlet {
...
}

In this case, all http methods are protected and accessible only by users with role javaee.

Example 2: Http Method Level

@WebServlet("/myurl")
@ServletSecurity(httpMethodConstraints={ @HttpMethodConstraint("GET"),
    @HttpMethodConstraint(value="POST", rolesAllowed={"javaee"}),
    @HttpMethodConstraint(value="TRACE", emptyRoleSemantic=ServletSecurity.EmptyRoleSemantic.DENY) })
public class TestServlet extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse res)
            throws IOException, ServletException {
        ...
    }

    protected void doPost(HttpServletRequest req, HttpServletResponse res)
            throws IOException, ServletException {
        ...
    }

    protected void doTrace(HttpServletRequest req, HttpServletResponse res)
            throws IOException, ServletException {
        ...
    }
}

The behaviors of the above servlet can be summarized as follows:

Http method	Behavior
GET	all can access GET method
POST	only authenticated users with role javaee can access POST method
TRACE	no one can access TRACE method

Example 3: A General Constraint for all Http methods with some Exceptional Cases

@WebServlet("/myurl")
@ServletSecurity(value=@HttpConstraint(rolesAllowed={"javaee"}),
    httpMethodConstraints={ @HttpMethodConstraint(value="POST", rolesAllowed={"staff"}),
    @HttpMethodConstraint("TRACE") })
public class TestServlet extends HttpServlet {
    ...

    protected void doPost(HttpServletRequest req, HttpServletResponse res)
            throws IOException, ServletException {
        ...
    }

    protected void doTrace(HttpServletRequest req, HttpServletResponse res)
            throws IOException, ServletException {
        ...
    }
}

The behaviors of the above servlet can be summarized as follows:

Http method	Behavior
POST	only authenticated users with role staff can access POST method
TRACE	all can access TRACE method
methods other than POST and TRACE	only authenticated users with role javaee can access

Note that in the previous definitions, the exceptional cases must be the standard http methods. There is no such restriction for the new annotations as illustrated by the Example 5 below.

Example 4: Https and protected for a given role

@WebServlet("/myurl")
@ServletSecurity(value=HttpConstraint(
    transportGuarantee=ServletSecurity.TransportGuarantee.CONFIDENTIAL),
    httpMethodConstraints={ @HttpMethodConstraint(value="TRACE", transportGuarantee=ServletSecurity.TransportGuarantee.NONE, rolesAllowed={"javaee"}) })
public class TestServlet extends HttpServlet {
    ...

    protected void doTrace(HttpServletRequest req, HttpServletResponse res)
        throws IOException, ServletException {

        ...
    }
}

The behaviors of the above servlet can be summarized as follows:

Http method	Behavior
TRACE	Https is supported. It just is not required. Only authenticated users with role javaee can access TRACE method
methods other than TRACE	require https

Example 5: Protect FOO only

@WebServlet("/myurl")
@ServletSecurity(value=@HttpConstraint,
httpMethodConstraints={ @HttpMethodConstraint(value="FOO", rolesAllowed={"javaee"}) })
public class TestServlet extends HttpServlet {
...
}

The behaviors of the above servlet can be summarized as follows:

Http method	Behavior
FOO	only authenticated users with role staff can access POST method
methods other than FOO	all can access

Atmosphere 0.4 Released

Mon, 26 Oct 2009 19:22:13 -0700

Atmosphere 0.4, the framework that allow the creation of RESTFul and Ajax Push/Comet applications, is ready for prime time. This release contains many new features and can be seen in action in many well-known frameworks.

First, I would like to thanks Paul Sandoz, Viktor Klang, Gerard Davison, Vlatko Davidobski, Hubert Iwaniuk, Bertrand Goetzmann,Cagatay Civici, Michal Hanti, A. Eduardo Garcia, Ransford Segu-Baffoe and Jim Driscoll for their contribution to that release!

Atmosphere's adoption continues with this release, starting with PrimeFaces' support for Ajax Push/Comet (event on the iPhone). You can also see Atmosphere in action within the Scala based Akka Project. Don't want to use Java? Why not using the Atmosphere Grails' plug in. Don't like Scala, Java and Groovy? Why not trying JRuby!

What's new since Atmosphere 0.3?

Easy integration with other Framework like Wicket and GWT
New Meteor API for easier integration with existing Servlet based applications

Support the latest Bayeux Protocol specification and implementation from the DOJO Foundation powered Cometd.org
The Atmosphere RESTful module can now be used with and without session support.
Works with EJB 3.1
New work-in-progress white paper (PDF)
The configuration file atmosphere.xml is now optional
Delayed and Scheduled Broadcast now supported.
The new Atmosphere Spade Server is an end-to-end stack that aggregate technology including the Grizzly Servlet Container, Jersey Runtime and The Atmosphere Framework and Plug In in single jar file! See how simple you can deploy on it, and it's production ready!

All Atmosphere modules are OSGi ready

You can now force Atmosphere to use Servlet 3.0 Async API or Blocking I/O API instead of Native Async API like Grizzly Comet, Tomcat AIO or Jetty Continuation

You can implement your own Comet support via the new CometSupport SPI
Many new sample like PubSub , GWT, Meteor, Embedded Atmosphere etc. now available

For any questions or to download Atmosphere, go to our main site and use our Nabble forum (no subscription needed) or follow us on Twitter and tweet your questions there!

technorati: atmosphere framework cluster comet scala ajax

Mojarra 2.0.1 has shipped

Fri, 23 Oct 2009 14:10:46 -0700

Just a short post to note that we've now shipped Mojarra 2.0.1. This version fixes a very serious bug when running on Tomcat. You can pick up the files from the usual places, see the release notes for more information. If you're using GlassFish, and already running 2.0.0 (you leading edge adopter!), there's probably no reason to upgrade - though the new v3 (b69) has the updated jar, and it will be propagated via the usual Update Center distribution.

Request aggregation in JSF 2 Ajax

Mon, 19 Oct 2009 13:59:26 -0700

I've had a few requests for request aggregation, ala RichFaces queues, in JSF 2. This was deliberately not included in JSF 2.0, but it will be considered for JSF 2.1. The reason why is simple - there was simply not very much time, once all the base Ajax work was completed, to add any additional features. However, adding this functionality yourself isn't actually very hard. Here's an example of how.

For those not familiar with the idea of request aggregation, the idea is a pretty simple one: in cases where the user may generate a large number of requests (for instance, with the keyup event), you're going to want to wait and see if you can bundle the requests together, so you don't spam the server with thousands of tiny little requests.

The example will have two parts: a JSF page, and some backing JavaScript. The end result will be a program which accepts input, and echos it out to another part of the page via an Ajax request to the server. There's also a status area to show a little of what's going on during the call.

Here's the form:

 1 <h:form id="form1" prependId="false"> 2 <h:outputScript name="jsf.js" library="javax.faces" target="head"/> 3 <h:outputScript name="javascript/aggregate.js" target="head"/> 4 5 Output: <h:outputText id="out1" value="#{echo.str}"/> 6 <br/> 7 Input: <h:inputText id="in2" value="#{echo.str}" autocomplete="off" 8 onkeyup="aggregate('out1 in1', this)"/> 9 <br/> 10 Status: 11 <br/> 12 <textarea id="status" rows="10" cols="50" readonly="readonly"/> 13 </h:form>

And here's the backing JavaScript:

 1 var increment = 1000; 2 var token; 3 function aggregate(target, element) { 4 window.clearTimeout(token); 5 addStatusMessage("cleared request, requeued"); 6 var send = function send() { 7 jsf.ajax.request(element, null, {render: target}); 8 }; 9 token = window.setTimeout(send, increment); 10 } 11 12 function addStatusMessage(message) { 13 var statusElement = document.getElementById("status"); 14 var status = statusElement.value; 15 var now = new Date(); 16 var timestamp = now.getHours() + ':' + now.getMinutes() + ':' + now.getSeconds(); 17 status = timestamp + ' ' + message + '\n' + status; 18 statusElement.value = status; 19 } 20 21 jsf.ajax.addOnEvent(function(data) { 22 if (data.status === "begin") { 23 addStatusMessage("request sent"); 24 } 25 });

This program is simple enough that it's function should be pretty self evident - but in case you've never worked with JavaScript timers, here's the control flow.

When you type a character into the input field, the aggregate function is called (JSF page line 8). If an outstanding request is already there, it will be canceled (JavaScript line 4), and a status message will be written (JavaScript lines 12-19) to a readonly textarea in the page (JSF page line 12). Then, a new request will be submitted, which will go off after 1 second (JavaScript line 9). If you type a new character before the second has elapsed, then the first request is canceled (JS line 4), before being submitted again with a new value (JS line 9). If a whole second goes by without a new keypress, then the request will finally be sent to the server, which will also trigger calling the event function (JS lines 21 - 24), which in turn writes out a status (JS lines 12-19), to the textarea (JSF line 12).

So, all told, the aggregation code was about 6 lines of JavaScript. And while that may be a trifle annoying, I can only assume that anyone writing a component like Autocomplete will include this into the component so you never need see it.

As always, feel free to ask questions on this post in the comments.

Mojarra is FCS!

Mon, 19 Oct 2009 13:28:01 -0700

After years of effort, I'm delighted to echo Ryan Lubke's announcement that Mojarra 2.0 is final!

Please check Ryan's blog for all the details. You can download it directly from the project website, or just use maven to get the latest stuff.,.

Mojarra 2.0.0 is available!

Mon, 19 Oct 2009 10:25:38 -0700

Mojarra 2.0.0 is now available!

There are several ways to obtain the release.

GlassFish V3 promoted build 69 (out later this week)
Download directly from https://javaserverfaces.dev.java.net
Download using Maven2 using information provided here

Please review the release notes as there are important details there pertaining to differences between the implementation and the specification as well as a basic migration guide from 1.2 to 2.0 (note that this is a live document, so we'll be making additions - check back regularly).

The JSF 2.0 tutorial from our Sun documentation team should be available in the coming weeks. As soon as it is, we'll send out a notification. Until then, here are some nice resources for JSF 2.0:

Andy Schwartz' blog entry - What's New in JSF 2
Ed Burns' blog - http://www.java.net/blogs/edburns/
Jim Driscoll's blog - http://www.java.net/blogs/driscoll
JSF 2.0 EG blog - http://blogs.jsfcentral.com/jsf2group/

On the tools+JSF 2.0 front, NetBeans is well underway with the JSF 2.0 support. I'd recommend grabbing the NetBeans development build and try it out! Ed noted the other day that you could highlight a section of markup in a Facelet template and extract it into a composite component. Slick! The JetBrains guys have been busy as well. Check out their blog on JSF 2.0 support within Maia.

I'd like to personally thank all of our external contributors who have been committing code to the repository directly or submitting patches to help improve our quality (these are in no particular order - my apologies if I've missed anyone):

Guy Veraghtert
Imre Oßwald
Ted Goddard
Mark Collette
Dan Allen
Alexandr Smirnov
Martin Marinschek
Michael Kurz
Andy Schwartz

I'd also like to thank our top three issue reporters for taking the time to log issues (again, in no particular order)

Frank Hofmann
Guy Veraghtert
Juergen Zimmerman

Also, thanks to Ed Burns, Roger Kitain, Jim Driscoll, and Doug Donahue for putting up with me for the past two years while we worked on this project :)

Finally, if you'd like to discuss JSF 2.0 with other users, I'd recommend the following:

GlassFish Webtier Forums
##jsf IRC channel on freenode.net

The GlassFish Webtier forums are monitored by the Mojarra developers. The IRC channel, also, is frequented by the Mojarra developers, as well as folks from Exadel, MyFaces, and consumers of JSF as a technology. It's a great way to interact with the community.

I'm excited that we've reached this stage and am looking forward to hearing/reading about people's experiences with JSF 2.0!

JSF2 Facelet Tag Handlers

Thu, 15 Oct 2009 12:47:59 -0700

The following topics and more will be covered in detail in my upcoming book with Neil Griffin, JavaServer Faces 2.0: The Complete Reference. Please enjoy this early access content!

One challenging aspect of designing JSF 2.0 was how to standardize Facelets. We wanted to standardize only the minimum amount that would still allow developers get the job done. Initially, we did not include binary custom tag handlers in the standard because most users of Facelets were simply using it to declare pages of existing UI components. Andy Schwartz and others advocated for the inclusion of a custom tag handler feature in the standard but I didn't want to just standardize what Jacob had initially done.

While Jacob's initial work for custom tag handlers was certainly effective, EG discussions with Ken Paulsen, creator of the JSFTemplating View Declaration Language led the EG to conclude that the standardization work for some of Facelets would best be left to JSF 2.1. In particular, Ken and EG member Imre Oßwald came up with something they called View Abstract Syntax Tree that would handle deeper aspects of Faces templating that they felt solved some of the flaws in the implementation of Facelets. Rather than overspecify, we came up with a simpler solution that still enables the most common usecases for custom tag handlers.

First, let's take a look at the custom.taglib.xml file. The manner and location for this file is exactly the same as before. In this example, (available in the Mojarra svn repo), the file lives at WEB-INF/classes/META-INF/custom.taglib.xml.

<?xml version="1.0" encoding="UTF-8"?>
 
<facelet-taglib xmlns="http://java.sun.com/xml/ns/javaee"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
 http://java.sun.com/xml/ns/javaee/web-facelettaglibrary_2_0.xsd"
              version="2.0">
    <namespace>http://mojarra.dev.java.net/custom</namespace>
    <tag>
        <tag-name>custom1</tag-name>
        <component>
            <component-type>javax.faces.Input</component-type>
            <renderer-type>javax.faces.Text</renderer-type>
            <handler-class>com.sun.faces.facelets.custom.CustomComponentHandler1</handler-class>
        </component>
    </tag>
    
 
 
</facelet-taglib>
 

The java code for this class is shown next. At right, you see the stack trace for a breakpoint set on line 8.

package com.sun.faces.facelets.custom;
 
import javax.faces.view.facelets.ComponentConfig;
import javax.faces.view.facelets.ComponentHandler;
 
public class CustomComponentHandler1 extends ComponentHandler {
    public CustomComponentHandler1(ComponentConfig config) {
        super(config);
    }
}
 

The preceding code does nothing. But it's a start. Particurlarly useful is that ComponentConfig argument. This gives you access to a whole bunch of useful stuff. Note also that extends javax.faces.view.facelets.ComponentHandler. There are handlers for all the kinds of tags in JSF: converter, validator, component, and behavior.

In many cases, the only reason people were doing custom Facelet tags was so they could be notified when the component is built. To get this in JSF 2.0, just override the onComponentCreated() method, as shown in the next class.

package com.sun.faces.facelets.custom;
 
import javax.faces.component.UIComponent;
import javax.faces.view.facelets.ComponentConfig;
import javax.faces.view.facelets.ComponentHandler;
import javax.faces.view.facelets.FaceletContext;
 
public class CustomComponentHandler2 extends ComponentHandler {
 
    public CustomComponentHandler2(ComponentConfig config) {
        super(config);
    }
 
    @Override
    public void onComponentCreated(FaceletContext ctx, UIComponent c, UIComponent parent) {
        super.onComponentCreated(ctx, c, parent);
    }
 
    @Override
    public void onComponentPopulated(FaceletContext ctx, UIComponent c, UIComponent parent) {
        super.onComponentPopulated(ctx, c, parent);
    }
 
}
 

The stack traces for onComponentCreated and onComponentPopulated are here and here, respectively.

If you really must have access to the apply method, and indeed override it, you can still do so. However, to preserve a clean separation between interface and implementation there is a little extra syntatic sugar you must endure. Sorry. Here's the code for a custom tag handler that overrides apply() and createMetaRuleset(). The stack trace for apply() is shown at left, while the one for createMetaRuleset() is available here.

package com.sun.faces.facelets.custom;
 
import java.io.IOException;
import javax.faces.component.UIComponent;
import javax.faces.view.facelets.ComponentConfig;
import javax.faces.view.facelets.ComponentHandler;
import javax.faces.view.facelets.FaceletContext;
import javax.faces.view.facelets.MetaRuleset;
import javax.faces.view.facelets.TagHandlerDelegate;
 
public class CustomComponentHandler3 extends ComponentHandler {
 
    public CustomComponentHandler3(ComponentConfig config) {
        super(config);
    }
 
    @Override
    public void onComponentCreated(FaceletContext ctx, UIComponent c, UIComponent parent) {
        super.onComponentCreated(ctx, c, parent);
    }
 
    @Override
    public void onComponentPopulated(FaceletContext ctx, UIComponent c, UIComponent parent) {
        super.onComponentPopulated(ctx, c, parent);
    }
 
    @Override
    protected TagHandlerDelegate getTagHandlerDelegate() {
        final TagHandlerDelegate parent = super.getTagHandlerDelegate();
        TagHandlerDelegate result = new TagHandlerDelegate() {
 
            @Override
            public MetaRuleset createMetaRuleset(Class type) {
                return parent.createMetaRuleset(type);
            }
 
            @Override
            public void apply(FaceletContext ctx, UIComponent comp) throws IOException {
                parent.apply(ctx, comp);
            }
        };
        return result;
    }
}
 

As mentioned previously, there are handlers for all the different kinds of JSF artifacts that may appear in a Facelet page. The syntax in the .taglib.xml file is rather similar for all of them, but the one for the validator is shown next.

<tag>
    <tag-name>validator</tag-name>
    <validator>
        <validator-id>javax.faces.Required</validator-id>
        <handler-class>com.sun.faces.facelets.custom.CustomValidatorHandler</handler-class>
    </validator>
</tag>
 

Finally, here's the code for this custom validator.

package com.sun.faces.facelets.custom;
 
import java.io.IOException;
import javax.faces.component.UIComponent;
import javax.faces.view.facelets.FaceletContext;
import javax.faces.view.facelets.MetaRuleset;
import javax.faces.view.facelets.TagHandlerDelegate;
import javax.faces.view.facelets.ValidatorConfig;
import javax.faces.view.facelets.ValidatorHandler;
 
public class CustomValidatorHandler extends ValidatorHandler {
 
    public CustomValidatorHandler(ValidatorConfig config) {
        super(config);
    }
 
    @Override
    protected TagHandlerDelegate getTagHandlerDelegate() {
        final TagHandlerDelegate parent = super.getTagHandlerDelegate();
        TagHandlerDelegate result = new TagHandlerDelegate() {
 
            @Override
            public MetaRuleset createMetaRuleset(Class type) {
                return parent.createMetaRuleset(type);
            }
 
            @Override
            public void apply(FaceletContext ctx, UIComponent comp) throws IOException {
                parent.apply(ctx, comp);
            }
        };
        return result;
    }
}
 

The callstacks for apply() and createMetaRuleset() are here and here

80% of the time, there is no need for any custom tag handlers. If you're doing your job right, the logic should be in the UIComponent, Validator, Converter, etc. However, for that extra 20% of the time, you can use the above practices to get the job done.

Technorati Tags: edburns

Slides for JSF 2 up on Slideshare

Wed, 14 Oct 2009 12:36:16 -0700

I've posted the slides for the talk that Andy Schwartz and I did at Oracle Open World up on Slideshare.

Check 'em out.

An (almost) comprehensive list of Web Components

Wed, 14 Oct 2009 11:27:30 -0700

In talking with Andy Schwartz before our recent talk together at Oracle Open World, Andy mentioned that he'd like to see some new components make it in to JSF 2.1.

I'd like to see that too - but what new components? To aid the discussion, I thought it might be handy to make up a list of components that I think would be handy for JSF - but please, don't take this as an endorsement of any particular component for inclusion into the spec. At best, I can see us adding only a handful, perhaps 3 or so. Still, once started, this kind of project becomes it's own end - so I decided it might be good to publish such a list. Many of these components already exist in some form or another for JSF, or as a JavaScript Widget that could be wrapped in a JSF component - so most of them are available today.

Basic Html

Most of the basic HTML components are already well covered, but there would seem to be a little room for a few very basic components

File Upload
Formatted i18n data

Date entry/display
Time entry/display
Currency entry/display

Flat Tree
Static Progress Status
SingleRowSelect
HTML5

Navigation

Components for navigating from one page to another.

Breadcrumb Trail
Navigation List
Navigation Tree

Security

Components that deal with identity and authorization.

Java EE Login
Logout
Register
Forgotten Password/Username
Capcha

Simple Rich UI

Framebuster
Tabbed Pane
Spinner
Slider
Calendar
TimeSpinner
ColorPicker
ModalWindow
ModalDialog
Popup Menu
FloatingWindow
Tag Cloud
TabularData
Menubar
CommandBar (icon button)

Filthy Rich UI

Really elaborate graphical components. Harder to do as a standard, since styling becomes so important.

Carosel
Accordian
EditText (in place edit)
Shuttle (Switch List)
ComboBox
Collapsible Tree
RichTextEdit
RSSReader
Slideshow
Lightbox
Charting

Behaviors

Things that are probably best implemented as behaviors.

Tooltip
DragAndDrop
Clientside Validation

Ajax

AutoSuggest
Poll
Map
Progress Indicator
Busy Status Indicator

More?

I'm sure I've left some out - suggest more in the comments...

Fresh 0.9.2 activerecord-jdbc-adapter Release

Nick Sieger — Mon, 12 Oct 2009 11:30:45 -0700

As announced last week on the jruby-user list, 0.9.2, the latest activerecord-jdbc-adapter release, has been pushed out. Please install the gem in the usual fashion and try it out on your applications.

One of the most contentious bugs broke db:create and db:drop, ruining the quick-start workflow that Rails is known for. To fix this, a creative solution was needed that ended up bringing some nice benefits.

The problem stemmed from the fact that some database setup tasks in Rails 2.3 no longer load the environment; instead they just load the configuration data and work with that. This means that there is no easy way to hook into Rails and override those tasks, which is what activerecord-jdbc needs to do.

The solution I ended up with was to create a jdbc Rails generator that inserts a couple files into your rails application that inject the JDBC logic into ActiveRecord and the database rake tasks. To wit:

$ jruby script/generate jdbc exists config/initializers create config/initializers/jdbc.rb exists lib/tasks create lib/tasks/jdbc.rake

The upside of this new technique is that now that we have a way to ensure the JDBC adapter is properly injected into Rails, and you no longer need to use adapter names like jdbcmysql, jdbcsqlite3 and the like. The net result is that database.yml no longer needs to be modified for the default Rails databases (mysql, sqlite3, postgresql). So while we introduced one additional step in the process to bootstrap a Rails application under JRuby, the removal the step where database.yml needs to be modified results in a more predictable workflow.

The new JRuby-specific Rails workflow looks like the following, assuming you’ve installed the activerecord-jdbc-adapter gem into JRuby, along with the appropriate database driver gem (e.g, jdbc-mysql). (Of course, the gems only need to be installed once per JRuby installation.)

Create your Rails application as usual.
Run the jdbc generator as shown above.
Profit!

Additionally, if you maintain a Rails application template that you use to start a new application, you can simply add generate(:jdbc) to that template’s script.

What’s more, the presence of the JDBC files in your application are guarded and only inject JDBC support when running under JRuby, so you can safely keep them around when running Rails under multiple Ruby implementations.

For more details of what’s in the release please consult the mini-changelog on Rubyforge and the list of fixed issues in JIRA.

JSF 2, Custom Java Components, and Ajax Behaviors

Fri, 09 Oct 2009 16:30:48 -0700

Unlike most of my blog posts, where I try to describe the easiest possible way to do things, in this posting, I'll instead go over a Java-based custom JSF component that responds to the Ajax tag. The reason being that there simply aren't any examples out there of how to do this, and at least two people have expressed interest in finding exactly out how this is done. I'd advise anyone considering doing this to make really sure that you can't do the same thing in a Composite Component (you usually can), but sometimes, a Java-based custom JSF component is going to be required.

We're going to cover the following topics here, and it's going to be a little more code than usual, but I suspect that this will end up saving some folks a bunch of time, so lets plow forward. I'll cover:

Ajax listeners
Facelet components
Integrating the two

First, the Ajax Listener

An ajax listener, connected to your ajax event with the listener attribute, is a method that will be called every time the ajax request is made. For example, let's look at the following page section:

 1 Echo test: <h:outputText id="out" value="#{custom.hello}"/> 2 <br/> 3 Echo count: <h:outputText id="count" value="#{custom.count}"/> 4 <br/> 5 <h:inputText id="in" value="#{custom.hello}" autocomplete="off"> 6 <f:ajax event="keyup" render="out count eventcount" listener="#{custom.update}"/> 7 </h:inputText> 8 <br/> 9 Event count: <h:outputText id="eventcount" value="#{custom.eventCount}"/>

We've got three bean properties - hello (which is the string entered by the inputText), count (which is a count of the characters in hello, and eventCount (which is a count of the number of ajax requests). We also have a method on the bean, update (line 6), which will be called every time the ajax call is submitted.

The behavior of this page is pretty simple - every time you press a character in the inputText, the complete value of the input is echoed to the outputText "out" (line 1) - the length of "out" is written to "count" (line 3), and the "eventCount" outputText (line 9) has it's value incremented by one.

So - what code is in the bean? Here's the relevant bits:

 1 public void setHello(String hello) { 2 this.hello = hello; 3 } 4 public int getCount() { 5 return count; 6 } 7 public int getEventCount() { 8 return eventCount; 9 } 10 public void update(AjaxBehaviorEvent event) { 11 count = hello.length(); 12 eventCount++; 13 }

Not so bad - the only thing new here is that AjaxBehaviorEvent class - and we're not even using it. The update method will simply set up the values to be correct, and we let the Ajax render to the rest. So - listeners are easy.

Facelets Components

Now, we'll want to create a custom tag in Java. To do that, we'll need to make a few configuration file entries, and write a little java code. But first, let's see it used in the page:

In the XHTML header, we'll say:

 1 <html xmlns="http://www.w3.org/1999/xhtml" 2 xmlns:ui="http://java.sun.com/jsf/facelets" 3 xmlns:h="http://java.sun.com/jsf/html" 4 xmlns:f="http://java.sun.com/jsf/core" 5 xmlns:cu="http://javaserverfaces.dev.java.net/demo/custom-taglib">

Setting up the "cu" prefix (line 5) to point to "custom-taglib" (the whole URL is significant). Then later on in the page, we'll use it like so:

<cu:custom id="customId">

We then need to add an entry in web.xml:

 1 <context-param> 2 <param-name>javax.faces.FACELETS_LIBRARIES</param-name> 3 <param-value>/WEB-INF/custom-taglib.xml</param-value> 4 </context-param>

This points to our next config file, which is the filename on line 3. Here's its contents, in full:

 1 <facelet-taglib xmlns="http://java.sun.com/xml/ns/javaee" 2 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 3 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facelettaglibrary_2_0.xsd" 4 version="2.0"> 5 <namespace>http://javaserverfaces.dev.java.net/demo/custom-taglib</namespace> 6 <tag> 7 <tag-name>custom</tag-name> 8 <component> 9 <component-type>mycustom</component-type> 10 </component> 11 </tag> 12 </facelet-taglib>

Note that the namespace element on line 5 matches the URL we used for the namespace in the html element of the using page. We said this taglibrary will have one tag "custom" (line 7), which maps to the FacesComponent "mycustom". Where does it find the definition of "mycustom"? In the Java file defining the component, using the new @FacesComponent attribute. Here's the full Java code, leaving out the imports:

 1 @FacesComponent(value = "mycustom") 2 public class MyCustom extends UIComponentBase { 3 4 @Override 5 public String getFamily() { 6 return "custom"; 7 } 8 9 @Override 10 public void encodeEnd(FacesContext context) throws IOException { 11 12 ResponseWriter responseWriter = context.getResponseWriter(); 13 responseWriter.startElement("div", null); 14 responseWriter.writeAttribute("id",getClientId(context),"id"); 15 responseWriter.writeAttribute("name", getClientId(context),"clientId"); 16 responseWriter.write("Howdy!"); 17 responseWriter.endElement("div"); 18 } 19 }

In fact, the Java code itself is simple enough that I don't really think it requires any explanation. Putting the cu:custom tag in your page will now render Howdy!, surrounded by a div with the same id and name as you gave the component. All that's left is to add the Ajax. That... is a bit more complicated, but now that we've handled everything else, it's really just incremental.

Using f:ajax with your custom tag

To use the f:ajax tag, we'd like to, for instance, do something like this:

 1 <cu:custom id="customId"> 2 <f:ajax render="eventcount" listener="#{custom.updateEventCount}"/> 3 </cu:custom>

Meaning, we'd like to just decorate the tag, and let it do something "smart". In this case, we'll default to "onclick" (since we're dealing with a div, after all, we could also default to "onmouseover", for instance). It'd also be nice if we could still call the ajax listener. That'll require a bit more code. Here's the full Java component, with the additional ajax code. I'll go over it at the end:

 1 @FacesComponent(value = "mycustom") 2 public class MyCustom extends UIComponentBase implements ClientBehaviorHolder { 3 4 @Override 5 public String getFamily() { 6 return "custom"; 7 } 8 9 @Override 10 public void encodeEnd(FacesContext context) throws IOException { 11 12 ClientBehaviorContext behaviorContext = 13 ClientBehaviorContext.createClientBehaviorContext(context, 14 this, "click", getClientId(context), null); 15 16 ResponseWriter responseWriter = context.getResponseWriter(); 17 responseWriter.startElement("div", null); 18 responseWriter.writeAttribute("id",getClientId(context),"id"); 19 responseWriter.writeAttribute("name", getClientId(context),"clientId"); 20 Map<String,List<ClientBehavior>> behaviors = getClientBehaviors(); 21 if (behaviors.containsKey("click") ) { 22 String click = behaviors.get("click").get(0).getScript(behaviorContext); 23 responseWriter.writeAttribute("onclick", click, null); 24 } 25 responseWriter.write("Click me!"); 26 responseWriter.endElement("div"); 27 } 28 29 30 @Override 31 public void decode(FacesContext context) { 32 Map<String, List<ClientBehavior>> behaviors = getClientBehaviors(); 33 if (behaviors.isEmpty()) { 34 return; 35 } 36 37 ExternalContext external = context.getExternalContext(); 38 Map<String, String> params = external.getRequestParameterMap(); 39 String behaviorEvent = params.get("javax.faces.behavior.event"); 40 41 if (behaviorEvent != null) { 42 List<ClientBehavior> behaviorsForEvent = behaviors.get(behaviorEvent); 43 44 if (behaviors.size() > 0) { 45 String behaviorSource = params.get("javax.faces.source"); 46 String clientId = getClientId(context); 47 if (behaviorSource != null && behaviorSource.equals(clientId)) { 48 for (ClientBehavior behavior: behaviorsForEvent) { 49 behavior.decode(context, this); 50 } 51 } 52 } 53 } 54 } 55 56 @Override 57 public Collection<String> getEventNames() { 58 return Arrays.asList("click"); 59 } 60 61 @Override 62 public String getDefaultEventName() { 63 return "click"; 64 } 65 }

At 65 lines, this is probably the longest code example I've ever posted, but most of this is either really easy, or stuff you've seen in the previous section. First, we define what Ajax events we'll accept ("click") and what one is the default ("click" again), on lines 56-64. These are part of the ClientBehaviorHolder interface (line 2). We also had to add a little code to the encodeEnd method, so that we correctly output the DOM event script as part of the div (lines 12-14, 20-24). And lastly, we needed to add a decode method, since our component is no longer output only - the ajax event handling code is always part of the decode process (lines 31-50). This is the part where we actually make sure that that listener is being called.

Did I mention that you can do pretty much the same thing in a composite component? That'll be the subject of a future blog.

Well, I warned you this was a little more complex - hopefully it's all fairly clear. If it isn't - ask in the comments.

JSF2 and POST Redirect GET

Thu, 08 Oct 2009 18:56:35 -0700

The image on the left is a screengrab I took when I was reviewing content for my upcoming book, with Neil Griffin, JavaServer Faces 2.0: The Complete Reference. I consider this little snippet an atonment for the HTTP violations of JSF versions past (before I was spec lead). Sorry about that.

For the record, the article referred to in the book is at <http://www.theserverside.com/tt/articles/article.tss?l=RedirectAfterPost>.

Technorati Tags: edburns

Attachment	Size
jsf2-prg.png	102.27 KB

Atmosphere at Oracle OpenWorld Unconference

Wed, 07 Oct 2009 17:32:32 -0700

@jfarcand will talk about the Atmosphere Framework at the upcoming Oracle OpenWorld (October 13th Tuesday, 1-2pm). If you are around, come to learn what is Atmosphere and how you can write RESTful and Asynchronous Web (Comet/Ajax Push) application using Scala, JRuby, Java or Groovy!

I will describe what is the Atmosphere Framework and its components, where the community is and how our next release 0.4 is going, demonstrate the framework power using JRuby, Scala, Java and Groovy (via the new Atmosphere Grails Plug In). I will also talk about the role of the framework in akka (RESTFul Distributed Persistent Transactional Actors), and conclude by transforming GlassFish V3 into an Atmosphere-OSGI-only Server. Sound like a lot of buzzwords, does it! If you can't come, just follow us on Twitter since everything about the framework and its evolution are twitted on line.

technorati: atmosphere framework cluster comet scala ajax

TOTD #111: Rails Scaffold for a pre-existing table using Oracle and GlassFish

arungupta — Wed, 07 Oct 2009 03:31:41 -0700

Content available at: http://blog.arungupta.me/2009/10/totd-111-rails-scaffold-for-a-pre-existing-table-using-oracle-and-glassfish/.

TOTD #110: JRuby on Rails application using Oracle on GlassFish

arungupta — Tue, 06 Oct 2009 16:00:00 -0700

Content available at: http://blog.arungupta.me/2009/10/totd-110-jruby-on-rails-application-using-oracle-on-glassfish/.

Slides for JSF 2 and Ajax

Mon, 05 Oct 2009 09:33:21 -0700

I've placed my slides for my JSF 2 and Ajax talk up on slideshare.

Check 'em out, and ask questions in the comments.

Mixing Ajax and full requests in JSF 2.0

Thu, 01 Oct 2009 18:20:54 -0700

JSF 2.0 makes ajax pretty easy - but it can't hide everything from you... It's tempting to just add a few ajax tags into your page, and not worry too much about interactions - here's one example of a problem you may run into.

Let's say you've got a page with an input text, and a command button - like this:

 1 <h:form> 2 <h:inputText value="#{blah.blah}"> 3 </h:inputText> 4 <h:commandButton/> 5 </h:form>

Now, we decide to add an ajax tag:

 1 <h:form> 2 <h:inputText value="#{blah.blah}"> 3 <f:ajax event="blur"/> 4 </h:inputText> 5 <h:commandButton/> 6 </h:form>

Can you spot what's wrong with this example? When we push the button, we're also blurring the inputText. That means that the ajax request is sent - but then, almost immediately, that request is canceled as the whole page is reloaded.

Is this a bad thing? For this simple example, not so much. There's going to be a broken connection - and that can be a grim problem for a large server, especially if you start getting one on each page, for each use.

But the real issue is that you've just set up a race condition. Imagine instead you did this:

 1 <h:form> 2 <h:inputText value="#{blah.blah}"> 3 <f:ajax event="blur" listener="#{bean.somethingthatchangesstate}"/> 4 </h:inputText> 5 <h:commandButton/> 6 </h:form>

Now we've got a real problem from that race condition - did the listener execute? Maybe. Maybe is never a good answer in software.

So - what to do?

Probably the best solution is also the simplest:

 1 <h:form> 2 <h:inputText value="#{blah.blah}"> 3 <f:ajax event="blur" listener="#{bean.somethingthatchangesstate}"/> 4 </h:inputText> 5 <h:commandButton> 6 <f:ajax render="@form"> 7 </h:commandButton> 8 </h:form>

Switching to ajax for the commandButton will now provide a predictable call sequence.

One more issue: When the two connections are submitted simultaneously, an error alert may be produced. I just updated that error to say: "The Http Transport returned a 0 status code. This is usually the result of mixing ajax and full requests. This is usually undesired, for both performance and data integrity reasons." What happens if you want to do this? Well, the error alert only shows up under two conditions, both of which must be true - the Project Stage must be Development, and there must be no error listener set. So, if you're really sure you want to mix ajax and full requests, despite what I said above, just set up an error listener for your ajax code - you'll want to anyway for a production environment.

As always, if you have questions, please ask in the comments.

JSF 2.0 Reminder: Project Stage

Mon, 28 Sep 2009 11:16:04 -0700

Just a reminder that while you are developing a JSF 2.0 project, you really, really, really should enable the Development Project Stage. Doing this enables better error messages, including in the client side JavaScript, at the cost of some performance.

Enabling this is as simple as putting the below into your web.xml:

<context-param>
<param-name>javax.faces.PROJECT_STAGE</param-name>
<param-value>Development</param-value>
</context-param>

When going into production, simply change the project stage to Production, like so:

<context-param>
<param-name>javax.faces.PROJECT_STAGE</param-name>
<param-value>Production</param-value>
</context-param>

This will turn off some error messages, and emphasize performance.

Jython 2.5.1 Final is out!

Frank Wierzbicki — Sat, 26 Sep 2009 07:36:00 -0700

On behalf of the Jython development team, I'm pleased to announce that Jython 2.5.1 final is available for download. See the installation instructions.

Jython 2.5.1 fixes a number of bugs, including some major errors when using coroutines and when using relative imports, as well as a potential data loss bug when writing to files in append mode. Please see the NEWS file for detailed release notes.

Please report any bugs that you find. Thanks!

Jython 2.5.1 Release Candidate 3 is out

Frank Wierzbicki — Wed, 23 Sep 2009 14:54:00 -0700

On behalf of the Jython development team, I'm pleased to announce that Jython 2.5.1rc3 is available for download. See the installation instructions.

I didn't really want to have an RC3, I was hoping to have a final by now, but a data loss bug was discovered in RC2 and that prompted one more RC. I'm hoping that this is the last one and that we'll have a final shortly. Please see the NEWS file for detailed release notes.

Please report any bugs that you find. Thanks!

TOTD #104: GlassFish v3 Monitoring – How to monitor a Rails app using asadmin, JavaScript, jConsole, REST ?

arungupta — Tue, 22 Sep 2009 23:00:53 -0700

Content available at: http://blog.arungupta.me/2009/09/totd-104-glassfish-v3-monitoring-how-to-monitor-a-rails-app-using-asadmin-javascript-jconsole-rest/

Video from Secrets of the Rockstar Programmers at Jazoon on Parleys

Tue, 22 Sep 2009 18:30:09 -0700

Ed has developed a 50 minute audio-visual presentation recounting his experience in writing the book. This presentation includes audio clips from the programmers themselves, including subtitles for those for whom English is not their native language, together with insight to tie it all together.

Ed has given this presentation at numerous international developer conferences and user groups around the world, including JAX in Germany, Jazoon in Switzerland, The Developer's Conference in São Paulo, Brazil and the Rich Web Experience in U.S.A..

See the presentation online now!

Audio and Video from Ed's presentation at Jazoon 2009 is available at Parleys.com, at the URL: <http://purl.oclc.org/NET/RidingTheCrest/Show>. Unfortunately, the subtitles did not come through on this presentation, but those viewing the presentation live do see them.

Technorati Tags: edburns

Free Rails/GlassFish Webinar with live Q&A: Sep 23, 2009,10am PT

arungupta — Fri, 18 Sep 2009 05:00:00 -0700

Content available at: http://blog.arungupta.me/2009/09/free-railsglassfish-webinar-with-live-qa-sep-23-200910am-pt/

Popular Ruby-on-Rails applications on GlassFish v3 – Redmine, Typo, Substruct

arungupta — Thu, 17 Sep 2009 23:14:51 -0700

Content available at: http://blog.arungupta.me/2009/09/redmine-typo-mephisto-on-glassfish-v3/

PyCon 2010 Call For Talks Ends Soon!

Frank Wierzbicki — Wed, 16 Sep 2009 13:20:00 -0700

If you where thinking about submitting a talk to PyCon 2010 you should do it now!

Grizzly 1.9.18 is out

Mon, 14 Sep 2009 10:13:39 -0700

We have been quiet for awhile with the monster...but we keep making improvements, and this week the team is proud to announce the GA availability of 1.9.18

This version doesn't contains any new features as we have focused on performance and fixing bugs. The change logs can be found here. Note that we are more and more to work on the Grizzly Servlet Container and make it pass the Servlet 2.5 TCKs. Hopefully before the end of the year we will have it working on both Grizzly 1.9.x and 2.0.0! On The Grizzly 2.0.0 side, we have been swamped by the upcoming GlassFish v3 release all summer (hopefully Oracle allow us more resources :-))....but 1.9.18 should be the last one integrated in v3, hence we will resume our full time work on completing Grizzly 2.0.0. GlassFish v3 is a heavy user of the Grizzly HTTP Framework: ALL Scripting language support: JRuby, Python and Groovy, the Admin CLI, Monitoring/Management REST API (with the help of Jersey's GrizzlyAdapter), EJB WebServices, Java WebStart, etc.....

Finally, one interesting use of Grizzly can be seen with the Atmosphere Framework, which offer an end to end stack for writing Comet and REST applications with the help of Jersey.

For any questions or to download samples and tutorials, go to our main site and use our Nabble forum (no subscription needed) or follow us on Twitter and tweet your questions there!

technorati: grizzly nio framework embedded

Jython 2.5.1 Release Candidate 2 is out!

Frank Wierzbicki — Sat, 12 Sep 2009 08:04:00 -0700

On behalf of the Jython development team, I'm pleased to announce that Jython 2.5.1rc2 is available for download. See the installation instructions.

Jython 2.5.1rc2 fixes bugs that we found when testing rc1, including some db, codec, and locking issues. Please see the NEWS file for detailed release notes.

Please report any bugs that you find. Thanks!

JRubyConf 2009: First of Many!

Nick Sieger — Fri, 11 Sep 2009 21:22:15 -0700

I’m so excited to see the news finally hit the wire today about the paint drying on the plans for JRubyConf 2009!

We always joked about having the first JRubyConf in the middle of a brisk Minnesota winter at Tom’s Cabin, but I think this will do nicely!

Please go quickly and register! Though there is no fee for the day, we only have a limited number of spots available!

P.S. This post is a little late to the party; I was in the air on the way back from JavaZone. If you want a peek at what’s been happening in JRuby land you can check out the slides from my talk there.

Announcing JRubyConf 2009

Charles Oliver Nutter — Fri, 11 Sep 2009 04:58:00 -0700

Good news everybody! We're finally going to have JRubyConf!

After over 3 years of heavy development, dozens of deployments and hundreds of users, it's time for a conference for JRuby users. We've talked about it on the JRuby mailing lists, polled users, and seen other JRubyists do the same. And the chorus slowly grew: you all wanted JRubyConf more and more.

Now, thanks to Engine Yard, who's producing the conference, and to sponsors EdgeCase and ThoughtWorks, we'll host the first ever JRubyConf the day after RubyConf, on Sunday November 22nd. This should allow folks attending RubyConf to also attend JRubyConf and not have to schedule a separate trip.

So here's the details:

What: JRubyConf 2009 (the first ever!)
When: Sunday, November 22nd; the day after RubyConf 2009
Where: Same hotel as RubyConf, the Embassy Suites at San Francisco Airport. You don't even have to switch locations!
Why: Because we love you!
Price: FREE!!!

We've been putting together a wide range of talks and speakers, from the JRuby core team members to real-world users; from the latest on deploying Rails to gaming and desktop development. It's going to be a fast-paced event with something for everyone, and best of all, it's FREE!

Space is limited for the event, and you will have to register separately from RubyConf to secure your seat (but you don't have to go to RubyConf to attend JRubyConf!). Check out www.jrubyconf.com for information, registration, and so on, and be quick about it!

See you at JRubyConf 2009!

Writing Comet Applications Using JRuby and the Atmosphere Framework

Thu, 10 Sep 2009 10:42:20 -0700

Writing Atmosphere's Comet based applications is simple. Imagine using JRuby instead of Java...it becomes really simple!. As with Scala, it is also possible to write Comet application with Atmosphere Framework using JRuby.

A user of Atmosphere recently posted the famous chat application written using JRuby and an embedded instance of Jetty. I've decided to write the same application using the Atmosphere Spade Server, which build on top of Jersey and Grizzly (will soon support Netty and Jetty). The idea behind the Atmosphere Spade Server is to make it really simple to test and embed your Comet application. Note that any application written using the Atmosphere Spade Server is portable, e.g. it will also deploy into any Servlet Container like Tomcat, Glassfish, Weblogic etc.

Before jumping into JRuby, let's just explore the Atmosphere Spade Server main class, AtmosphereSpadeServer:

public static AtmosphereSpadeServer.build(String uri);

Invoking that simple method will automatically creates, under the hood, a Grizzly Servlet Container instance ready to receive requests based on the URI entered

AtmosphereSpadeServer.build("http://localhost:8080/")

Next step is to add your Atmosphere POJO aka AtmosphereHandler (I recommend you read that post for more details about AtmosphereHandler ):

AtmosphereSpadeServer.build("http://localhost:8080/").addAtmosphereHandler(...);

And finally, you are ready to start it:

AtmosphereSpadeServer.build("http://localhost:8080/").addAtmosphereHandler(...).start();

If you are using Atmosphere Core/REST (powered by Jersey), it event simpler as you don't need to define AtmosphereHandler, but instead just tell Jersey the name of the package to look for JAX RS resources:

AtmosphereSpadeServer build("http://localhost:8080/","org.atmosphere.myresources").start()

Now let's jump into JRuby world and uses the AtmosphereSpadeServer:

 1 require 'java' 2 3 Dir["./Java/atmosphere/atmosphere-spade-server.jar"].each { |jar| require jar } 4 5 include_class 'javax.servlet.http.HttpServlet' 6 include_class 'org.atmosphere.cpr.AtmosphereHandler' 7 include_class 'org.atmosphere.grizzly.AtmosphereSpadeServer' 8 9 #setup and start the server 10 def main 11 AtmosphereSpadeServer.build("http://localhost:8080/") 12 .addAtmosphereHandler("", ChatPage.new()) 13 .addAtmosphereHandler("/chat-stream", ChatStream.new()).start 14 end

The above code starts the server using two AtmosphereHandler. The first will send back a chat.html page to be rendered by the browser

 17 #serve the chat page 18 class ChatPage 19 include AtmosphereHandler 20 21 def onEvent(event) 22 Kernel.load(__FILE__) 23 res = event.getResponse() 24 25 res.setContentType("text/html") 26 res.addHeader("Cache-Control", "private") 27 res.addHeader("Pragma", "no-cache") 28 File.open(File.dirname(__FILE__)+'/chat.html').each { |line| 29 res.getWriter().write(line) 30 } 31 res.getWriter().flush() 32 event 33 end 34 end

The second one is used for suspending the response and broadcasting chat messages

 36 #serve the chat stream and post messages 37 class ChatStream 38 include AtmosphereHandler 39 40 BEGIN_SCRIPT_TAG = '<script>' 41 END_SCRIPT_TAG = '</script>' 42 43 def onEvent(event) 44 req = event.getRequest(); 45 res = event.getResponse(); 46 47 res.setContentType("text/html") 48 res.addHeader("Cache-Control", "private") 49 res.addHeader("Pragma", "no-cache") 50 res.setCharacterEncoding("UTF-8"); 51 52 if (req.getMethod().upcase === "GET") 53 # for IE 54 res.getWriter().write("<!-- Comet enables web " + 55 "servers to send data without having any need " + 56 "for the client to request it. -->\n"); 57 res.getWriter().flush(); 58 event.suspend(); 59 60 elsif (req.getMethod().upcase === "POST") 61 message = req.getParameterValues("message")[0].to_s 62 ip = req.getRemoteAddr().to_s 63 event.getBroadcaster().broadcast( 64 BEGIN_SCRIPT_TAG + 65 "window.parent.say('<small>#{ip} - #{req.getHeader("User-Agent").to_s}: </small><br><b>#{message}</b>')" + 66 END_SCRIPT_TAG); 67 68 res.getWriter().write('success') 69 res.getWriter().flush(); 70 end 71 72 event 73 end 74 75 def onMessage(event) 76 writer = event.getResponse().getWriter() 77 writer.write(event.getMessage().to_s.ljust(1*1024)) 78 writer.flush() 79 event 80 end 81 end

With Atmosphere, every suspended connection are represented by an instance of AtmosphereEvent, and when a Broadcast operations happens, the AtmosphereHandler.onMessage(AtmosphereEvent) will be invoked hence an application can write back the broadcasted message.

Of course, you can do much more complex application using Atmosphere and JRuby, but my goal here was just to show how easy it can be.

For any questions or to download the above sample, go to our main site and use our Nabble forum (no subscription needed) or follow us on Twitter and tweet your questions there!

technorati: atmosphere framework jruby comet scala ajax

Context And Dependency Injection (JSR 299) And Servlets

Wed, 09 Sep 2009 07:34:21 -0700

I've had questions about how to inject Web Beans into servlets and whether that is supported. In this entry I'll outline a method of accomplishing just that.
This is a simple login application that communicates to a servlet using Ajax calls from a JSP view. I'm not going to focus on the view or the protocol (Ajax) that is used to communicate with the servlet. If you are interested in that, you can check out the source (instructions at the end of this post). I'm going to focus on the servlet code and the supporting classes for the application. The application just prompts for a user name / pasword, and pressing the submit button sends those values to a servlet. First, let's take a look at some of the supporting code for the application:

Listing 1: Login Credentials

package webbeansservlet;
import javax.enterprise.context.RequestScoped;
import javax.enterprise.inject.Default;
import javax.inject.Named;
/**
* This is just a simple container class Web Bean for the username
* and password entry values.
*/
@Named
@RequestScoped
@Default
public class Credentials {
private String username = null;
private String password = null;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}

Line 11: The name of this Web Bean will be credentials since we don't supply an argument to the Named annotation.
Line 12: For the purposes of this simple application this Web Bean scope will be for the current request.
Line 13: Specifies the default qualifier type for this Web Bean. Note that you should not have to specify this if it's the only qualifier type being used. In future implementations of Web Beans this should be fixed.

Listing 2: Login

package webbeansservlet;
import java.io.Serializable;
import javax.enterprise.context.SessionScoped;
import javax.enterprise.inject.Default;
import javax.inject.Inject;
import javax.inject.Named;
/**
* A simple Web Bean that performs a login operation with user's
* credentials.
*/
@Named
@SessionScoped
@Default
public class Login implements Serializable {
@Inject Credentials credentials;
private boolean loggedIn = false;
/**
* This is where you could potentially access a database.
*/
public void login() {
if ((credentials.getUsername() != null &&
credentials.getUsername().trim().length() > 0) &&
(credentials.getPassword() != null &&
credentials.getPassword().trim().length() > 0)) {
loggedIn = true;
}
}
public boolean isLoggedIn() {
return loggedIn;
}
}

Line 13: The name of this Web Bean will be login
Line 14: This Web Bean will exist for the session
Line 15: Specifies the default qualifier type for this Web Bean.
Line 18: We're injecting an instance of Credentials so we can check the validity of the user name and password entries

Listing 3: Login Servlet

package webbeansservlet;
import java.io.IOException;
import java.io.PrintWriter;
import javax.enterprise.inject.spi.BeanManager;
import javax.inject.Inject;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* This Servlet class demonstrates Web Beans injection.
*/
@WebServlet(name="LoginServlet", urlPatterns={"/LoginServlet"})
public class LoginServlet extends HttpServlet {
// Inject Web Beans Bean Manager.
@Inject BeanManager m;
// Inject The Credentials Web Bean.
@Inject Credentials credentials;
// Inject the Login Web Bean.
@Inject Login login;
/**
* Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
* @param request servlet request
* @param response servlet response
* @throws ServletException if a servlet-specific error occurs
* @throws IOException if an I/O error occurs
*/
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
credentials.setUsername(request.getParameter("username"));
credentials.setPassword(request.getParameter("password"));
login.login();
try {
if (login.isLoggedIn()) {
out.println("Successfully Logged In As: " + credentials.getUsername());
} else {
out.println("Login Failed: Check username and/or password.");
}
} finally {
out.close();
}
}
.......
}

Line 15: New for Servlet 3.0 - eliminates servlet entry in web.xml! Not relevant to this example, but worth mentioning.
Line 19: The Web Beans Bean Manager can also be injected. The Bean Manager api provides some useful methods for interrogating portions of a Web Beans application.
Line 22: The Credentials Web Bean is injected making it available to the servlet.
Line 38: Now we can access the Credentials Web Bean.
Line 40: We can also use the injected Login Web Bean instance.

This is just one example of Web Bean injection into a servlet. There are more areas in the JavaEE6 platform that can be used as Web Bean injection points - topics that will certainly be covered in future posts. The sample for this blog can be found under the glassfish-samples project. You can check out the code following these instructions. Once the workspace is checked out, you can find this sample under glassfish-samples/ws/javaee6/webbeans/webbeans-servlet. You can find documentation for the sample under glassfish-samples/ws/javaee6/webbeans/webbeans-servlet/docs. As with all the Web Beans samples now, you should run with GlassFish V3 - any build after September 2 2009.

Contexts and Dependency Injection (JSR 299) and GlassFish

Fri, 04 Sep 2009 12:34:20 -0700

Version 1.0.0.PREVIEW3 of Web Beans (the implementation for JSR 299 Contexts and Dependency Injection For Java EE) now uses the annotations from JSR 330 (Dependency Injection For Java) and it is available in GlassFish V3.
In this entry, we'll look at a simple JSF 2 application that uses Web Beans and the JSR 330 annotations. There are other features available in this release of Web Beans which will be discussed in subsequent blog entries. This application is a simple "guess number" application which I'm sure we are probably all familiar with by now. Let's start by taking a look at the application's UI markup.

Listing 1: User Interface Markup

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core">
<h:head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>JSF 2.0 Web Beans Example</title>
</h:head>
<h:body>
<h:form id="NumberGuessMain">
<h:panelGrid styleClass="title-panel">
<h:outputText value="Guess Number" styleClass="title-panel-text"/>
<h:outputText value="Powered By JavaServer Faces 2.0 and Web Beans" styleClass="title-panel-subtext"/>
</h:panelGrid>
<div style="color: black; font-size: 24px;">
I'm thinking of a number between <span style="color: blue">#{game.smallest}</span> and <span style="color: blue">#{game.biggest}</span>. You have <span style="color: blue">#{game.remainingGuesses}</span> guesses.
</div>
<h:panelGrid border="1" columns="5" style="font-size: 18px;">
Number:
<h:inputText id="inputGuess" value="#{game.guess}" required="true" size="3" disabled="#{game.number eq game.guess}" validator="#{game.validateNumberRange}"/>
<h:commandButton id="GuessButton" value="Guess" action="#{game.check}" disabled="#{game.number eq game.guess}"/>
<h:commandButton id="RestartButton" value="Reset" action="#{game.reset}" immediate="true" />
<h:outputText id="Higher" value="Higher!" rendered="#{game.number gt game.guess and game.guess ne 0}" style="color: red"/>
<h:outputText id="Lower" value="Lower!" rendered="#{game.number lt game.guess and game.guess ne 0}" style="color: red"/>
</h:panelGrid>
<div style="color: red; font-size: 14px;">
<h:messages id="messages" globalOnly="false"/>
</div>
<h:outputStylesheet name="stylesheet.css" />
</h:form>
</h:body>
</html>

Everything on this page is really just standard JSF 2.0 view markup. I've emphasized the Expression Language (EL) portions of the view, especially game because it refers to a contextual bean instance also known as a Web Bean.

Line 17: Binding to Web Bean properties
Line 21: Binding to Web Bean properties and validation method
Line 22, 23: Binding to Web Bean action method
Line 24, 25: Binding to Web Bean properties

As you can see, in JSF, binding to a Web Bean is no different than binding to a typical managed bean.

Supporting Classes And Annotations For The Applicaton

Let's take a look at some of the utility classes for the application, namely the classes that are used to generate a random number and some of the supporting annotations.

Listing 2: The "Random" Annotation

package webbeansguess;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import javax.inject.Qualifier;
@Target( { TYPE, METHOD, PARAMETER, FIELD })
@Retention(RUNTIME)
@Documented
@Qualifier
public @interface Random {
}

The JSR 330 @Qualifier annotation is used to make Random a binding type. This will allow us to inject a random number into the application.

Listing 3: The "MaxNumber" Annotation

package webbeansguess;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.inject.Qualifier;
@Target( { TYPE, METHOD, PARAMETER, FIELD })
@Retention(RUNTIME)
@Documented
@Qualifier
public @interface MaxNumber {
}

Likewise, the @Qualifier annotation is used to make MaxNumber a binding type that will allow us to inject the maximum number allowed (for a guess) in the application.

Listing 4: The "Generator" Class

package webbeansguess;
import java.io.Serializable;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.inject.Produces;
@ApplicationScoped
public class Generator implements Serializable {
private static final long serialVersionUID = -7213673465118041882L;
private java.util.Random random = new java.util.Random( System.currentTimeMillis() );
private int maxNumber = 100;
java.util.Random getRandom() {
return random;
}
@Produces @Random int next() {
return getRandom().nextInt(maxNumber);
}
@Produces @MaxNumber int getMaxNumber() {
return maxNumber;
}
}

Line 7: An instance of this class exists for the lifecycle of the application
Line 15: next() is a Web Beans producer method. It will get called by the Web Beans Manager to obtain an instance of the next random number.
Line 18: getMaxNumber() is also a Web Beans producer method. It will get called by the Web Beans Manager to obtain an instance of maxNumber - essentially returning the maximum number to "guess" in the application (in this case "100").

The Anatomy of a Simple Contextual Bean

Now that we have are utility classes and annotations in place, we can use them in our Web Bean.

Listing 5: The "Game" Contextual Bean

package webbeansguess;
import java.io.Serializable;
import javax.annotation.PostConstruct;
import javax.enterprise.context.SessionScoped;
import javax.enterprise.inject.Instance;
import javax.inject.Inject;
import javax.inject.Named;
import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.component.UIInput;
import javax.faces.context.FacesContext;
@Named
@SessionScoped
public class Game implements Serializable {
private static final long serialVersionUID = 1L;
private int number;
private int guess;
private int smallest;
@MaxNumber @Inject
private int maxNumber;
private int biggest;
private int remainingGuesses;
@Random @Inject Instance<Integer> randomNumber;
public Game() {
}
public int getNumber() {
return number;
}
public int getGuess() {
return guess;
}
public void setGuess(int guess) {
this.guess = guess;
}
public int getSmallest() {
return smallest;
}
public int getBiggest() {
return biggest;
}
public int getRemainingGuesses() {
return remainingGuesses;
}
public String check() throws InterruptedException {
if (guess>number) {
biggest = guess - 1;
}
if (guess<number) {
smallest = guess + 1;
}
if (guess == number) {
FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("Correct!"));
}
remainingGuesses--;
return null;
}
@PostConstruct
public void reset() {
this.smallest = 0;
this.guess = 0;
this.remainingGuesses = 10;
this.biggest = maxNumber;
this.number = randomNumber.get();
}
public void validateNumberRange(FacesContext context, UIComponent toValidate, Object value) {
if (remainingGuesses <= 0) {
FacesMessage message = new FacesMessage("No guesses left!");
context.addMessage(toValidate.getClientId(context), message);
((UIInput)toValidate).setValid(false);
return;
}
int input = (Integer) value;
if (input < smallest || input > biggest) {
((UIInput)toValidate).setValid(false);
FacesMessage message = new FacesMessage("Invalid guess");
context.addMessage(toValidate.getClientId(context), message);
}
}
}

I've color coded the areas of interest in this class. The blue areas are JSR 299 (Web Beans) implementation details. The red areas are JSR 330 (Dependency Injection For Java) areas. The purple areas are the binding types.

Line 14: We are using the Named annotation to associate a name with this bean. Because there is no argument specified with the Named annotation, its name will be the name of the bean itself with the first letter lowercase (game). This allows us to reference the bean by that name using the Expression Language in the view.
Line 15: We declare this bean as a session scoped bean, meaning it's lifecycle is the lifecycle of the session.
Line 23: The producer method in the Generator class (line 18) will service this injection point causing maxNumber to have a value of "100".
Line 29: The producer method in the Generator class (line 15) will service this injection point making a randomNumber instance available for this Web Bean.
Line 72: We use a standard @PostConstruct annotation causing variable initialization (after this Web Bean is created).
Line 78: Our Web Bean has been created, so the randomNumber.get() call will cause the producer method in the Generator class (line 15) to get called.

Well, that's a quick overview of a simple JSF2 application that uses the Web Beans (JSR 299 implementation) and the Java Dependency Injection (JSR 330) annotations. You can find this version of Web Beans in any of the GlassFish V3 builds after September 2, 2009.

Dealing Gracefully with ViewExpiredException in JSF2

Thu, 03 Sep 2009 19:55:54 -0700

My previous entry dove under the covers for JSF 2.0 and examined composite component metadata. This one is far less esoteric and shows how to handle the ViewExpiredException using a new JSF feature, the ExceptionHandler, contributed by Pete Muir a JSF Expert Group representative from JBoss.

JSF throws a ViewExpiredException when a postback is made to a view and, for whatever reason, that view cannot be restored. Usually this is due to a session timeout, but a custom state management solution could also cause this exception to be thrown. The default behavior in JSF2 is to show the Facelets error page saying View Expired. The default page is illustrated at right.

One way to fix this is to declare an <error-page> element in your web.xml, as shown here.

    <error-page>
        <exception-type>javax.faces.application.ViewExpiredException</exception-type>
        <location>/faces/viewExpired.xhtml</location>
    </error-page>
 

This works well enough. You can even put JSF components on the error page if you put the proper Faces Servlet mapping in the <location> element, as shown above. If you want to do some application level manipulation in response to the exception, you'll want something different, however. In this case, a custom ExceptionHandler is just the trick. I cover this in much more detial in my upcoming book, JavaServer Faces 2.0: The Complete Reference, and the example shown in this blog entry is neatly integrated into the chapter 10 sample app. Consider this blog entry an appetizer. So delete that old web.xml (it's not needed if you have JSF2 and Servlet 3, which you get in Glassfish V3) and let's go.

First, we need to install a custom ExceptionHandler. This is done using the tried and true JSF decorator pattern. In this case, we place the following into the faces-config.xml. There's no annotation for this because it's relatively uncommon, and we expect advanced users to use the feature. Therefore, the EG tradeoff was to not add yet another "scan for this annotation" clause to the spec.

  <factory>
      <exception-handler-factory>com.sun.faces.ViewExpiredExceptionExceptionHandlerFactory</exception-handler-factory>
  </factory>
 

Here's the code for the class.

package com.sun.faces;
 
import javax.faces.context.ExceptionHandler;
import javax.faces.context.ExceptionHandlerFactory;
 
public class ViewExpiredExceptionExceptionHandlerFactory extends ExceptionHandlerFactory {
 
    private ExceptionHandlerFactory parent;
 
    public ViewExpiredExceptionExceptionHandlerFactory(ExceptionHandlerFactory parent) {
        this.parent = parent;
    }
 
    @Override
    public ExceptionHandler getExceptionHandler() {
        ExceptionHandler result = parent.getExceptionHandler();
        result = new ViewExpiredExceptionExceptionHandler(result);
 
        return result;
    }
 
 
}

The interesting things happen on lines 15 - 20. This method is called once per request must return a new ExceptionHandler instance each time it's called. I know the method name should be createExceptionHandler, but we stuck with "get" for consistence with other JSF methods. On line 17, we call the real ExceptionHandlerFactory and ask it to create the instance, which we then wrap in our custom ViewExpiredExceptionExceptionHandlerFactory class. This is where the real interesting stuff happens.

package com.sun.faces;
 
import java.util.Iterator;
import java.util.Map;
import javax.faces.FacesException;
import javax.faces.application.NavigationHandler;
import javax.faces.application.ViewExpiredException;
import javax.faces.component.UIViewRoot;
import javax.faces.context.ExceptionHandler;
import javax.faces.context.ExceptionHandlerWrapper;
import javax.faces.context.FacesContext;
import javax.faces.event.ExceptionQueuedEvent;
import javax.faces.event.ExceptionQueuedEventContext;
 
public class ViewExpiredExceptionExceptionHandler extends ExceptionHandlerWrapper {
 
    private ExceptionHandler wrapped;
 
    public ViewExpiredExceptionExceptionHandler(ExceptionHandler wrapped) {
        this.wrapped = wrapped;
    }
 
    @Override
    public ExceptionHandler getWrapped() {
        return this.wrapped;
    }
 
    @Override
    public void handle() throws FacesException {
        for (Iterator<ExceptionQueuedEvent> i = getUnhandledExceptionQueuedEvents().iterator(); i.hasNext();) {
            ExceptionQueuedEvent event = i.next();
            ExceptionQueuedEventContext context = (ExceptionQueuedEventContext) event.getSource();
            Throwable t = context.getException();
            if (t instanceof ViewExpiredException) {
                ViewExpiredException vee = (ViewExpiredException) t;
                FacesContext fc = FacesContext.getCurrentInstance();
                Map<String, Object> requestMap = fc.getExternalContext().getRequestMap();
                NavigationHandler nav =
                        fc.getApplication().getNavigationHandler();
                try {
                    // Push some useful stuff to the request scope for
                    // use in the page
                    requestMap.put("currentViewId", vee.getViewId());
 
                    nav.handleNavigation(fc, null, "viewExpired");
                    fc.renderResponse();
 
                } finally {
                    i.remove();
                }
            } 
        }
        // At this point, the queue will not contain any ViewExpiredEvents.
        // Therefore, let the parent handle them.
        getWrapped().handle();
 
    }
}
 
    
 

On line 15, you see we take advantage of the javax.faces.context.ExceptionHandlerWrapper convenience class. JSF has lots of these wrapper classes and when you use them, you need only override the getWrapped() method to return the instance of the class you're wrapping, which is often simply passed to the constructor, as shown on lines 19 - 21. Once you override getWrapped(), you need only override those methods you're interested in. In this case, we want to override only handle(), which we do on lines 29 - 57.

We iterate over the unhandler exceptions using the iterator returned from getUnhandledExceptionQueuedEvents().iterator(), as shown on line 30. The ExeceptionQueuedEvent is a SystemEvent (also described in detail in my book) from which we can get the actual ViewExpiredException, which I do on line 35. I know I'm going to be ultimately showing a JSF page so I want to extract some information from the exception and place it in request scope, so I can access it via EL in the page. I do this on line 37.

On lines 45 and 46, I leverage the JSF implicit navigation system and cause the server to navigate to the "viewExpired" page. This assumes, of course, that there is a viewExpired.xhtml page out there. Naturally, you could parameterize this howevere you like, context-param, annotation, whatever. Line 46 causes the intervening lifecycle phases to be skipped.

Note that we have a try-finally block here, and in the finally block, on line 49, we call remove() on the iterator. This is an important part of the ExceptionHandler usage contract. If you handle an exception, you have to remove it from the list of unhandled exceptions. That way, we know it's safe to call getWrapped().handle() on line 55.

Finally, let's see my cheesy viewExpired.xhtml page in action, shown at left.

This page is not much more visually appealing than the default one, but that's not JSF's fault! The one in the JSF2 book will look nicer. Here's the source for this cheesy one.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core">
<h:head>
  <title>Nice View Expired Page</title>
</h:head>
<h:body>
<h:form>
 
    <p>To protect your security, we have taken the liberty of logging you
    out. Those who sacrifice liberty for security deserve to have
    their views expired.</p>
 
    <p>You were on page #{currentViewId}.  Maybe that's useful.</p>
 
  </h:form>
</h:body>
</html>
    
 

Note that we show the data from the exception on line 15.

This entry showed you how to programmatically intercept the ViewExpiredException and do something nice with it. If you have any other state that you can show in the page, it's easy to include it in the Facelets view.

Technorati Tags: edburns

Latest functionality in GlassFish v3 logging.

Wed, 02 Sep 2009 17:33:50 -0700

This blog highlights some of the changes that are part of GlassFish v3 logging. Since Prelude I have added 3 asadmin commands related to logging. I have updated the set-log-level command and changed the syntax. See below for details. The new commands are:

    * asadmin rotate-log
    * asadmin list-logger-levels
    * asadmin set-log-level logger-name=level:logger-name=level

The first command rotates the log files immediately. Users can now use native scheduling software such as cron to rotate the logs. We still support rotating logs based on file size or elapsed time since the last log rotation and this new command allows more flexibility when rotating log files. The second command lists the loggers and their current level. This command reports on all the known loggers that are listed in logging.properties file. Note that in some cases the loggers may not have been created by the respective containers however they will still appear in the list. The third command, asadmin set-log-level, sets the level for aone or more loggers.   For example, to set the log level of the web container logger level to WARNING simply type: asadmin set-log-level javax.enterprise.system.container.web=WARNING. This command updates the logging.properties file which means that the values are persisted across server restart. Use asadmin list-logger-levels to get the names of the loggers.

Finally, I've added a property to logging.properties file in the domain config directory that controls the number of message written to the server log file. GlassFish v3 logging code writes messages to a queue instead of directly to the server log file. Log messages are taken off the queue and written to the server log file as cycles become available. The property name is com.sun.enterprise.server.logging.GFFileHandler.flushFrequency. This propertys controls the number of messages that are taken off the queue and written to a file a time. The actual number written is the value of this property or less depending on the number of messages in the queue. The default value is 1.

JSF2 Composite Component Metadata

Wed, 02 Sep 2009 09:53:21 -0700

This ultra-quick blog entry shows how to use the JSF runtime to access metadata for a composite component. Note that most of the metadata is optional when creating a composite component, therefore, this entry will be of interest to tool vendors and those wishing to write composite components that stand a chance of showing up nicely in tools.

The Using Page

When showing a composite component demo, I always like to start out with the using page.

Listing 1: the using page

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:my="http://java.sun.com/jsf/composite/cc"
      xmlns:meta="http://mojarra.dev.java.net/cc-metadata">
<h:head>
  <title>A Simple JavaServer Faces 2.0 View</title>
<style type="text/css">
.grayBox { padding: 8px; margin: 10px 0; border: 1px solid #CCC; background-color: #f9f9f9;  }
</style>
 
</h:head>
<h:body>
  <h:form>
 
    <p>Composite Component usage:</p>
 
<div id="cc" class="grayBox" style="border: 1px solid #090;">
<my:myComponent loginAction="#{userBean.loginAction}" />
</div>
 
<h2>Metada for This Composite Component</h2>
 
<div id="foo" class="grayBox" style="border: 1px solid #090;">
    <pre>
    <meta:printMetadata viewName="main.xhtml" libraryName="cc"
                        resourceName="myComponent.xhtml"/>
    </pre>
</div>
 
 
    <p><h:commandButton value="submit" /></p>
  </h:form>
</h:body>
</html>
 

Line 5 declares the namespace “my” using the handy composite component namespace prefix “http://java.sun.com/jsf/composite” followed by “cc”. JSF 2 interprets this to mean: treat any .xhtml files in the directory /resources/cc as a JSF composite component.

Line 6 declares a Facelet custom tag library with the namespace “http://mojarra.dev.java.net/cc-metadata”.

Line 20 uses the composite component named “myComponent” in the “cc” library.

Line 27 uses the “printMetadata” component from the Facelet custom tag library. We must pass in the name of a Facelet page, the library name, and the resource name.

The Composite Component

Let's examine the composite component itself. As I mentioned earlier, most of this metadata is optional and is included here just to show what the system understands. This component has just about every kind of metadata that is in the JSF2 spec.

Listing 2 the composite component

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:ui="http://java.sun.com/jsf/facelets"
      xmlns:fmd="http://java.sun.com/xml/ns/javaee/faces/design-time-metadata"
      xmlns:cc="http://java.sun.com/jsf/composite">
<head>
 
<title>Not present in rendered output</title>
 
</head>
 
<body>
 
<cc:interface
    name="component"
    displayName="A really fancy composite component"
    expert="true"
    hidden="false"
    preferred="true"
    shortDescription="This component has all the supported metadata."
    extraTopLevelAttribute="Whatever I want here">
 
<!-- start top level attributes -->
 
  <cc:attribute
    name="model"
    required="true"
    displayName="model"
    expert="false"
    hidden="false"
    preferred="true"
    shortDescription="The model for this component"
    extraTopLevelAttribute="Whatever I want here">
    <cc:extension>
      <fmd:expert>true</fmd:expert>
    </cc:extension>
    <cc:attribute
      name="userid"
      default="guest"
      displayName="User Id"
      expert="false"
      hidden="false"
      preferred="true"
      shortDescription="The model must have a userid property"/>
    <cc:attribute
      name="password"
      default="guest"
      displayName="Password"
      expert="false"
      hidden="false"
      preferred="true"
      shortDescription="The model must have a password property"/>
  </cc:attribute>
 
  <cc:attribute name="useridLabel" default="Userid:" />
 
  <cc:attribute name="passwordLabel" default="Password:" />
 
  <cc:attribute name="loginButtonLabel" default="Login" />
 
  <cc:attribute name="loginAction" method-signature="java.lang.String f()"
    required="true" />
 
<!-- end top level attributes -->
 
<!-- start facets -->
 
  <cc:facet
    name="header"
    displayName="The header facet for the fancy component"
    expert="true"
    hidden="false"
    preferred="false"
    shortDescription="If you want a header, this is where you put it"
    anotherExtraAttribute="Lots of metadata" />
 
  <cc:facet
    name="footer"
    displayName="The footer facet for the fancy component"
    expert="true"
    hidden="false"
    preferred="false"
    shortDescription="If you want a footer, this is where you put it"
    anotherExtraAttribute="Lots of metadata" />
 
<!-- end facets -->
 
<!-- start attached objects -->
 
  <cc:editableValueHolder
    name="userid"
    displayName="Userid field"
    expert="true"
    hidden="false"
    preferred="false"
    shortDescription="Attach a converter or validator here, if you like"
    someExtraMetadata="userid metadata" />
 
  <cc:editableValueHolder
    name="password"
    displayName="Password field"
    expert="true"
    hidden="false"
    preferred="false"
    shortDescription="Attach a converter or validator here, if you like"
    someExtraMetadata="password metadata" />
 
  <cc:actionSource
    name="login"
    displayName="Login button"
    expert="true"
    hidden="false"
    preferred="false"
    shortDescription="Attach an actionListener here, if you like"
    someExtraMetadata="login metadata" />
 
<!-- end attached objects -->
 
</cc:interface>
 
<cc:implementation>
 
  <cc:renderFacet name="header" />
 
  <p><h:outputLabel for="#{cc.clientId}:userid"
                    value="#{cc.attrs.useridLabel}" />
     <h:inputText id="userid" /></p>
 
  <p><h:outputLabel for="#{cc.clientId}:password"
                    value="#{cc.attrs.passwordLabel}" />
     <h:inputText id="password" /></p>
 
  <p><h:commandButton value="#{cc.attrs.loginButtonLabel}"
                      action="#{cc.attrs.loginAction}" /></p>
 
  <cc:renderFacet name="footer" />
 
 
</cc:implementation>
 
</body>
 
</html>
 

Lines 16 - 23 declare the top level composite component metadata.

Lines 25 - 65 declare the attributes that may be passed as XML elements on the composite component instance in the using page. Note that the loginAction attribute is declared as required on line 63. This is useful because Facelets will put up a helpful error if the page author doesn't supply a value here.

Lines 68 - 88 declare the allowable facets. In this case, they're optional.

Lines 90 - 119 declare the attached objects within the implementation section that are publically accessible from the using page.

Programmatically accessing the metadata

Up to this point, everything I've shown has been included in other blog entries elsewhere. What hasn't been shown is how the JSF runtime uses the metadata API to actually conjure up the composite component instance. This API is also accessible to tools that want to embed a JSF runtime into their tool environment. To show this off, I've created a non-composite JSF component and exposed it in the usual way, with a Facelet taglib. This still requires a descriptor, which is placed in WEB-INF/classes/META-INF.

Listing 3 the cc-metadata.taglib.xml

<facelet-taglib  xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
   xmlns='http://java.sun.com/xml/ns/javaee'
   xsi:schemaLocation='http://java.sun.com/xml/ns/javaee web-facelettaglibrary_2_0.xsd' 
   version="2.0">
    <namespace>http://mojarra.dev.java.net/cc-metadata</namespace>
    <tag>
        <tag-name>printMetadata</tag-name>
        <component>
            <component-type>jsf2.PrintMetadata</component-type>
        </component>
<!-- these are advisory and not enforced by the runtime -->
        <attribute>
            <name>viewName</name>
            <required>true</required>
        </attribute>
        <attribute>
            <name>libraryName</name>
            <required>true</required>
        </attribute>
        <attribute>
            <name>resourceName</name>
            <required>true</required>
        </attribute>
    </tag>
 
</facelet-taglib>

Lines 11 - 23 are optional but I like to include them for explicit documentation.

The JSF Component that shows how to access the metadata is in Listing 4 A. This listing covers obtaining a reference to the BeanInfo that is the composite component metadata.

Listing 4 A, Accessing the composite component metadata programmatically

package jsf2;
 
import java.beans.BeanInfo;
import java.io.IOException;
import javax.faces.FacesException;
import javax.faces.application.Resource;
import javax.faces.component.FacesComponent;
import javax.faces.component.UIOutput;
import javax.faces.context.FacesContext;
import javax.faces.context.ResponseWriter;
import javax.faces.view.ViewDeclarationLanguage;
 
@FacesComponent(value="jsf2.PrintMetadata")
public class PrintMetadata extends UIOutput {
 
    @Override
    public void encodeAll(FacesContext context) throws IOException {
        ResponseWriter writer = context.getResponseWriter();
        String
                viewName,
                libraryName,
                resourceName;
 
        try {
            viewName = this.getAttributes().get("viewName").toString();
            libraryName = this.getAttributes().get("libraryName").toString();
            resourceName = this.getAttributes().get("resourceName").toString();
        } catch (NullPointerException e) {
            throw new FacesException("Must supply viewName, libraryName and resourceName attributes");
        }
 
        ViewDeclarationLanguage vdl = context.getApplication().
                getViewHandler().getViewDeclarationLanguage(context, viewName);
        Resource compositeComponentResource = context.getApplication().getResourceHandler().createResource(resourceName, libraryName);
 
        BeanInfo metadata = vdl.getComponentMetadata(context, compositeComponentResource);
 
        CompositeComponentMetadataUtils.writeMetadata(metadata, writer);
 
    }
}
 

On lines 24 - 29 we extract the required attributes that have been passed to us via the page author.

On line 32, we obtain a reference to the ViewDeclarationLanguage instance for Facelets.

On line 34, we create a Resource instance using the passed in composite component library name and resource name.

Line 36 features the call o getComponentMetadata(). It is safe to call this method only during the context of the JSF request processing lifecycle. Because we're doing it from inside the rendering of a component, we know that this is such a context.

Finally, Listing 4 B shows a traversal of the metadata.

Listing 4 B, what you can do with the metadata

package jsf2;
 
import java.beans.BeanDescriptor;
import java.beans.BeanInfo;
import java.beans.FeatureDescriptor;
import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.util.Enumeration;
import java.util.List;
import java.util.Map;
import javax.el.ValueExpression;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.context.ResponseWriter;
import javax.faces.view.AttachedObjectTarget;
 
public class CompositeComponentMetadataUtils {
 
    /**
     * <p>Use the composite component metadata specification
     * in section JSF.3.6.2.1 to print out the metadata to
     * the argument writer.</p>
     * @throws IOException
     */
 
    public static void writeMetadata(BeanInfo metadata, 
            ResponseWriter writer) throws IOException{
 
        // Print out the top level BeanDescriptor stuff.
        BeanDescriptor descriptor = metadata.getBeanDescriptor();
        writeFeatureDescriptor("composite-component-BeanDescriptor", descriptor,
                writer);
        writeFeatureDescriptorValues(
                "composite-component-BeanDescriptor", descriptor,
                writer);
        PropertyDescriptor attributes[] = metadata.getPropertyDescriptors();
        for (PropertyDescriptor cur : attributes) {
            writeFeatureDescriptor("composite-component-attribute", cur,
                    writer);
            writeFeatureDescriptorValues("composite-component-attribute", cur,
                    writer);
        }
    }
 
    public static void writeFeatureDescriptor(String prefix,
            FeatureDescriptor fd, ResponseWriter writer) throws IOException {
 
        writer.write(prefix + "-name:" +
                fd.getName() + "\n");
        writer.write(prefix + "-displayName:" +
                fd.getDisplayName() + "\n");
        writer.write(prefix + "-shortDescription:" +
                fd.getShortDescription() + "\n");
        writer.write(prefix + "-expert:" +
                fd.isExpert() + "\n");
        writer.write(prefix + "-hidden:" +
                fd.isHidden() + "\n");
        writer.write(prefix + "-preferred:" +
                fd.isPreferred() + "\n");
 
    }
 
    public static void writeFeatureDescriptorValues(String prefix,
            FeatureDescriptor fd, ResponseWriter writer) throws IOException {
 
        Enumeration<String> extraValues = fd.attributeNames();
        String curName;
        while (extraValues.hasMoreElements()) {
            curName = extraValues.nextElement();
            if (curName.equals(AttachedObjectTarget.ATTACHED_OBJECT_TARGETS_KEY)) {
                List<AttachedObjectTarget> attachedObjects =
                        (List<AttachedObjectTarget>) fd.getValue(curName);
                for (AttachedObjectTarget curTarget : attachedObjects) {
                    writer.write(prefix + "-attached-object-" + curTarget.getName() + "\n");
                }
            } else if (curName.equals(UIComponent.FACETS_KEY)) {
                Map<String, PropertyDescriptor> facets =
                        (Map<String, PropertyDescriptor>) fd.getValue(curName);
                for (String cur : facets.keySet()) {
                    String facetPrefix = prefix + "-facet-" + cur;
                    writeFeatureDescriptor(facetPrefix, facets.get(cur),
                            writer);
                    writeFeatureDescriptorValues(facetPrefix,
                            facets.get(cur), writer);
                }
            } else {
                ValueExpression ve = (ValueExpression) fd.getValue(curName);
                writer.write(prefix + "-extra-attribute-" + curName + ": " +
                        ve.getValue(FacesContext.getCurrentInstance().getELContext())
                        + "\n");
            }
        }
    }
 
 
}
 

On line 30, we ask the argument BeanInfo for its BeanDescriptor. We pass this to the helper method writeFeatureDescriptor(). This simple method just prints out the standard FeatureDescriptor metadata.

On line 33, we pass the same descriptor to the helper method writeFeatureDescriptorValues(). This method steps through the Enumeration returned from attributeNames(), calls getValue() on each entry, and takes appropriate action on each entry, based on the metadata specification. Currently there are three kinds of entries.

Lines 70 - 75 deal with the attached objects. The type for this entry is List<AttachedObjectTarget>. AttachedObjectTarget encapsulates how an attached object, in this declared on lines 90 through 119 of Listing 1, exposes an inner component to the page author.
Lines 76 - 85 deal with the exposed facets. The type for this entry is Map<String, PropertyDescriptor>, where the key is the facet name and the PropertyDescriptor represents each individual <cc:facet> element. These are on lines 68 - 88 of Listing 1.
Lines 87 - 91 deal with the else case, which can be characterized as “if it's not the attached objects, and it's not the facets, then it'll just come to you as a ValueExpression.

Back up on line 36, we ask the metadata for the PropertyDescriptor [] using getPropertyDescriptors(). This is specified to return a PropertyDescritor for each of the attributes, in this case show on lines 25 - 64 of Listing 1. For each attribute, we print out the FeatureDescriptor and the values. However, note that in the case of attributes, there will only be ValueExpression instances in the getValue() data structure. A screengrab of the running page is show here.

When the Expert Group designed this api, we wanted to make it as easy as possible to provide tool support for composite components. I hope this is helpful to tool authors for this purpose.

Technorati Tags: edburns

Jython 2.5.1 Release Candidate 1 is out!

Frank Wierzbicki — Tue, 01 Sep 2009 04:07:00 -0700

On behalf of the Jython development team, I'm pleased to announce that Jython 2.5.1rc1 is available for download. See the installation instructions.

Jython 2.5.1rc1 fixes a number of bugs, including some major errors when using
coroutines and when using relative imports. Please see the NEWS file for
detailed release notes.

Please report any bugs that you find. Thanks!

What's New: Releases and Oh Right, a New Gig

Nick Sieger — Thu, 27 Aug 2009 13:12:00 -0700

So, after a long, busy summer, I’m finally back onto support of the various bits for JRuby web application development (meaning Warbler and JRuby-Rack). I’m pleased to announce the 0.9.5 release of JRuby-Rack and the 0.9.14 release of Warbler! All of this brought to you courtesy of Engine Yard, my new employer!

Both of these are long-overdue releases. Here’s the low-down on each:

JRuby-Rack 0.9.5

For the full history, see the 0.9.5 entry in the History.txt file.

One bad bug in particular prevented you from running Rack-powered Rails 2.3 out of the box at all because JRuby-Rack bundled an older version of Rack than needed by Rails. This has been fixed for good by not forcing JRuby-Rack’s bundled copy of Rack on your application; any version of Rack you include (either via gems or vendor’ed in Rails or your application) will take precedence.

Another major upgrade is the introduction of rewindable requests. The Rack spec dictates that the request IO object be rewindable and that server/handler writers (such as myself) need to buffer the input. You’d think that Java application servers would do this for you, but, as is the case with Java so often, servers perform the bare minimum amount of work and leave the grunt work to the application developer. So JRuby-Rack takes care of the input buffering for you. The first 64k of input data are buffered entirely in memory; above that the request body is dumped into a temp file. (64k is a default and is configurable. If you have a better suggestion for a default, let me know.)

Finally, this release brings back Java Servlet-based sessions for use with the Rack-based session mechanism. For those of you experimenting with hybrid Rails/Java applications and want to share session data between them, you’ll want this. Servlet sessions are not the default; you need to turn them on by setting ActionController::Base.session_store = :java_servlet_store.

Warbler 0.9.14

Warbler’s main change this release is to unbundle JRuby. When you install Warbler as a gem, you’ll now get a dependent gem called jruby-jars installed for you. We’ll be releasing a new version of this gem with every release of JRuby, and you’ll be able to upgrade JRuby versions without having to update Warbler.

JRuby-Rack is still bundled with Warbler for now (0.9.14 comes with JRuby-Rack 0.9.5 of course), but the jar file is not that big and the two projects tend to be released around the same time. By Warbler 1.0 I hope to have a mechanism to unbundle all jar files so that Warbler is just a lightweight Rake library with enough smarts to fetch the binaries your application needs.

Future

The projects seem to be headed for a 1.0 release soon. For these releases, I hope to ensure that they are both ready to take advantage of Rails 3 out of the box. One of the ways is to use Bundler in Warbler to manage gems. Hopefully as Rails 3 and other applications start to standardize Bundler manifests, it means less custom configuration for Warbler.

Since the core of JRuby-Rack seems to be stabilizing, the next promising step is to explore more ways to integrate with existing Java code and Java applications. This should dovetail nicely with JRuby’s plan for better Java integration in the upcoming JRuby 1.4 release. For example, Christian Seiler explained how he’s using JRuby-Rack to integrate JMS while running an in-memory ActiveMQ server for his site blissmessage.com. These kinds of ease-of-use scenarios where you can start a single process with all of your application needs: web server, message queue, timer for periodic tasks etc. present a great way to jumpstart a project. I’d like to see some of these APIs standardize so that we can transition from all-in-one development servers up to scalable production clusters where app, message queue, and other servers are separated and standalone.

The fellows over at Google have been busy this summer with the appengine-jruby project, and there are opportunities for tuning that experience as well.

Of course, your suggestions are welcome too. I’d appreciate it if you’d drop me a line if you’re doing something novel with these tools, so I can help shape future directions around people like you who are Getting Things Done with them!

(Postlude: Both these projects need a logo. If you can mock something up, I’d love to see some ideas!)

Introducing Surinx

Charles Oliver Nutter — Tue, 25 Aug 2009 20:52:00 -0700

In June of this year, I spent a few hours formulating a dynamic cousin to Duby. Duby, if you don't remember, is a static-typed language with Ruby's syntax and Java's type system. Duby supports all Ruby's literals, uses local type inference (only argument types *must* be declared), and runs as fast as Java (because it produces nearly identical bytecode). But with the advent of invokedynamic, Duby needed a playmate.

Enter "Juby". Juby is intended to be basically like Duby, in that it uses Java's types and Ruby's syntax. But it takes advantage of the new invokedynamic opcode to be 100% dynamic. Juby is a dynamic Duby, or perhaps a dynamic Java with Ruby syntax. It's not hard to comprehend.

But the name was a problem. Juby sounds like "Jewbie", a pejorative term for a Jewish person. So I sent out a call for names to the Twitterverse, ultimately ending up with far more names than I could choose from.

The name I have chosen, Surinx, has a simple story attached. You see, when James Gosling created Java, he originally named it "Oak", after the tree outside his window. So I followed his lead; the tree (a bush, really) outside my window is a lilac, Syringa vulgaris. The genus "Syringa" is derived from New Latin, based on a Greek word "surinx" meaning "shepherd's pipe" from the use of the Syringa plant's hollow stems to make pipes. Perhaps Surinx is building on the "hollow stem" of the JVM to produce something you can smoke (other dynamic languages) with. Combined with its cousin "Duby", we have quite a pair.

And in other news, the simple Surinx implementation of "fib" below (identical to Ruby) manages to run fib(40) in only 7 seconds on current MLVM (OpenJDK7 + invokedynamic and other tidbits), a five-fold improvement over JRuby's fastest mode (jruby --fast).

def fib(a)
 if a < 2
 a
 else
 fib(a - 1) + fib(a - 2)
 end
end

Given that JRuby has started to support invokedynamic, the solid performance of Surinx bodes very well for JRuby's future.

Please welcome Surinx to your language repertoire!

Tricks and Tips with Comet part 1: The Browser difference

Tue, 25 Aug 2009 14:39:36 -0700

Writing Comet application is more and more simple, thanks to framework like LIft and Atmosphere. On the Client side, the difference between Safari, Opera, Firefox, IE and Chrome can make your application completely unresponsive or broken. Of course, there is some tricks to make it work.

First, if you are new to Comet, I recommend you take a look at this introduction. For this serie, I will use my new project called Atmosphere, which is a framework for writing portable Comet and REST applications. I always use Firefox for developping, and recently I've got surprise when I 've realized all Atmosphere's sample did work on WebKit (Chrome, Safari) and Opera.

First, to make Safari works properly with the Comet technique called http streaming or forever frame, make sure, on the server side, you set the content-type properly and disable the cache.

        res.setContentType("text/html");
        res.addHeader("Cache-Control", "private");
        res.addHeader("Pragma", "no-cache");

That works well with GlassFish and Jetty...but not Tomcat. Why? Because both Jetty and GlassFish append the charset for you all the time, and Tomcat don't. Safari seems to not like it. So the proper code consist of:

        res.setContentType("text/html;charset=ISO-8859-1");
        res.addHeader("Cache-Control", "private");
        res.addHeader("Pragma", "no-cache");

Note that Firefox will work without the above, same for IE. Now the above will make the Comet technique called Long-polling working, but http streaming will still be broken on Safari. Why? Because when you suspend the response, if you don't fill out Safari with some data (~2k), all events that will happen once the response has been suspended will be written by the server, but never read/displayed in Safari, Chrome, IE and Opera. As an example, I always output the following junk before I suspend a response in Atmosphere:

private final static String JUNK = "\n";

......

            for (int i =0; i< 10; i++){
                res.getWriter().write(JUNK);
            }
            res.getWriter().flush();

If you are using Atmosphere REST module using Scala, you also need to do something like:

var JUNK : String = "\n"

    @Suspend
    @GET
    @Produces(Array("text/html;charset=ISO-8859-1"))
    def suspend() = {
        var s = new StringBuilder()
        for (i <- 0 to 10){
            s.append(JUNK)
        }
        s.toString()
    }

Quite paintfull but until websocket are widely adopted (will they?), you will need a little bit of hacking. But once you know them, that should be easy. Client library like JQuery and Dojo's Cometd implementation already do that for you, but if are using pure javascript (or iframe for the http streaming support), make sure you recall that simple tip. You can download many Comet samples from here. They work on any Java WebServer.

If you have any questions, post them on users@atmosphere.dev.java.net, use Nabble or or tweet them.

technorati: atmosphere framework browser comet scala ajax

Thursday at GooglePlex for an Eclipse Day

Mon, 24 Aug 2009 14:19:24 -0700

Bonjour, Comment Java?

This coming Thursday(08/27/09) 'll be at GooglePlex (Mountain View) for an Eclipse Day...The entire genda is at http://wiki.eclipse.org/Eclipse_Day_At_Googleplex_2009.

2 presos seem to be very interesting so far:

and possibly others...The Google crowd is impressive.

There is a waiting list for people who did not register in time:-) But I am sure online videos of the conference will be available as well.

Ludo (Testing the new Java.net Blog system)

Reviving Project WOM - WSDL Object Model

Thu, 20 Aug 2009 14:56:32 -0700

Sometime back I started a project - WOM, short for WSDL Object Model. The idea was to come up with a library that provides efficient parsing and provides a WSDL Object Model that can be used to inspect, traverse/navigate and will be useful for IDEs such as NetBeans and also WSDL 2 Java generators, such as Metro wsimport.

After some initial (90%) of work I left the project ideal to get back to it after I get past some other interesting things I was involved with. Recently someone from community sent me mail and asked whats up with this project and he plans to build some custome API using WOM and XSOM APIs for schema object model. I fixed some bugs, added documentations and released 0.9.0 version of WOM to maven.

The design of WOM is largely based on XSML Schema Object Model (XSOM). It is very extensible. For example, you can use your own ContentHandler to parse the XML Schema. Use your own extension handlers to parse WSDL extensibility elements. I need to do more work on adding documentation for these. But what I have there should be sufficient for you to start playing with it.

WOMParser parser = new WOMParser();
WSDLSet wsdls = parser.parse(new File("sample.wsdl"));
WSDLDefinitions def = wsdls.getWSDLs().next();

Refer to API doc on how to navigate and do some interesting things with the WSDL components.

See the project page for details and send your feedback.

InvokeDynamic and Jython part I

Frank Wierzbicki — Mon, 17 Aug 2009 04:26:00 -0700

The invokedynamic work from the Da Vinci Machine Project has come a long way. In fact, it has started to make it's way into OpenJDK 7 builds. To try the bleeding edge version out for yourself, follow these instructions to patch and build your own. But, be warned, it's a bit tricky to get started. You may find that these examples will work with OpenJDK 7 binaries (sooner or later they should!). For those who haven't heard about this work yet, invokedynamic, which is a part of JSR-292, allows a program to dynamically call methods with (potentially) the same performance characteristics as static calls. Here is about the simplest invokedynamic program you can write:


import java.dyn.CallSite;
import java.dyn.InvokeDynamic;
import java.dyn.Linkage;
import java.dyn.MethodType;
import java.dyn.MethodHandles;

public class Example {
 public static void main(String... av) throws Throwable {
 for (String a : av) {
 InvokeDynamic. call(a);
 }
 InvokeDynamic. call2(av[0]);
 }

 public static void foo(String x) {
 System.out.println("Hello, " + x);
 }

 static { Linkage.registerBootstrapMethod("linkDynamic"); }
 private static CallSite linkDynamic(Class caller, String name, MethodType type) {
 System.out.println("linking:" + name);
 CallSite c = new CallSite(caller, name, type);
 c.setTarget(MethodHandles.lookup().findStatic(Example1.class, "foo",
 MethodType.make(void.class, String.class)));
 return c;
 }
}

First notice the linkDynamic method. The static initializer above it registers that method as a special bootstrap method that invokedynamic will use when you want to call a method dynamically. The interesting bit to notice are the two calls to methods on InvokeDynamic. InvokeDynamic has no actual methods of its own. You can call any method on it (here I use "call" and "call2", but it could just as well have been "foo123" or "sasquatch") When you make these calls, control is passed to the bootstrap method (linkDynamic in this case). linkDynamic gets passed the Class of the caller, the name that was used ("call" and "call2" in this program) and the MethodType of the call, which specifieds the signature of the dynamic call.

To compile the above code, execute:

javac -XDinvokedynamic Example.java

To run it:

java -XX:+EnableMethodHandles -XX:+EnableInvokeDynamic Example a b c

Which should produce:


linking:call
Hello, a
Hello, b
Hello, c
linking:call2
Hello, a

Notice that we called "call" three times, but it only needed to be linked once. We then called call2 and it was separately linked. Had we invoked call2 again it would not have needed linking. Next in my exploration, I'll wire it up with some Python internal dispatch logic:


package org.python.compiler;

import java.dyn.CallSite;
import java.dyn.InvokeDynamic;
import java.dyn.Linkage;
import java.dyn.MethodType;
import java.dyn.MethodHandle;
import java.dyn.MethodHandles;
import java.dyn.MethodType;

import org.python.core.Py;
import org.python.core.PyCode;
import org.python.core.PyFunction;
import org.python.core.PyInteger;
import org.python.core.PyObject;
import org.python.core.PyString;
import org.python.core.PyTuple;
import org.python.core.ThreadState;

public class IndyTest {

 public static void run() throws Throwable {
 PyObject result = InvokeDynamic. foo(new PyInteger(4), Py.None,
 Py.EmptyObjects, new PyTuple());
 System.out.println("result = " + result);
 }

 static { Linkage.registerBootstrapMethod("linkDynamic"); }
 private static CallSite linkDynamic(Class caller, String name, MethodType type) {
 System.out.println("linkDynamic...");
 CallSite site = new CallSite(caller, name, type);
 ThreadState ts = Py.getThreadState();
 PyCode func_code = ((PyFunction)ts.frame.getname(name)).func_code;

 MethodType oneArgCall = MethodType.make(
 PyObject.class, //return type
 ThreadState.class, // state
 PyObject.class, // arg1
 PyObject.class, // globals
 PyObject[].class, // defaults
 PyObject.class // closure
 );
 MethodHandle call = MethodHandles.lookup().findVirtual(PyCode.class, "call", oneArgCall);
 call = MethodHandles.insertArguments(call, 0, func_code, ts);
 call = MethodHandles.convertArguments(call, type);
 site.setTarget(call);

 return site;
 }
}

There is a bit more going on here. In short, we look up the current state of the Jython interpreter when this is invoked and look for a function called "foo". We pass the PyInteger 4 (plus some boilerplate at the end -- in the future we should be able to only pass the 4, but MethodHandles.insertArguments can only add three arguments at the moment.) to the foo(), and then print the result out. Again "foo" is bound the first time it is called. When we create a CallSite, grab the current ThreadState and get our "foo" object from the current Jython frame. We then create a MethodType that corresponds to the way that we call Jython methods internally, and use methods off of MethodHandles (insertArguments and convertArguments) to coerce our call to the internal call semantics. Then our "foo" call is permanently bound to the function we found. Ultimately this is not what we will want since "foo" could be rebound in Jython in a number of ways. We'll get to this problem in a future post. To try this code out, we need a Jython program with a foo method:


def foo(x):
print "hello %s!" % x
foo("test")

from org.python.compiler import IndyTest
IndyTest.run()

def foo(x):
print "goodbye %s!" % x
foo("test")

IndyTest.run()

Run it like this (requires a Jython 2.5 install and we need to call Jython with --boot to put the Jython internals into the boot classpath):


jython --boot -J-XX:+EnableMethodHandles -J-XX:+EnableInvokeDynamic indy.py


hello test!
foo = 1
linkDynamic...
hello 4!
result = None
goodbye test!
foo = 2
hello 4!
result = None

The first IndyTest.run() looks great (hello 4!) -- but the second call still emits "hello 4!" even though foo() has been redefined. We'll look at fixing this in the next post.

By the way, to *really* learn about the guts of invokedynamic look to the posts from John Rose and Fredrik Öhrström along with the Da Vinci Machine site.