Marcus Christie's Blog

How to dynamically change the Tweet Button's tweet text

2011-07-09T13:20:00.006-04:00

Looked around on the internet for a way to dynamically change the tweet text of the Tweet Button, but didn't find a good solution. Most of what I found involved setting the text when the page is being rendered server side or client side. But what I need for FuelMyRoute.com is a way to dynamically update the tweet text based on the user's activity in the page after it has rendered. (Specifically, based on the route provided by the user, I want to update the tweet text to say something specific about how much the user has saved per gallon of gas.)

The solution I went with uses the iframe Tweet Button, and basically you just need a bit of javascript to manipulate the URL that configures the iframe Tweet Button. I went with the iframe Tweet Button over the javascript Tweet Button because the javascript one manipulates the DOM and replaces your anchor tag with an iframe, etc. You could theoretically dynamically change the tweet text for the javascript Tweet Button but it would be a little brittle, being dependent on how the javascript Tweet Button renders itself.

Enough jibber jabber, on to the code! You start by adding an iframe Tweet Button to the page:

Then you need this function which updates the text parameter of the iframe Tweet Button's query string (which of course will cause the button to reload):

You can try it out right here. Click on the Tweet Button below and preview the message, which should be "Replace Me":

Now click on the button below which will call updateTweetButtonText('I just dynamically updated the text of a Tweet Button!'); and then click on the Tweet Button again to see that the preview tweet has been updated:

A Review of Homeschooling

2009-12-08T10:26:00.012-05:00

Imagine you are a parent of a child attending a school. Your child brings home one of her exams and on this exam is a question the answer to which is marked incorrect. Your child asks you why it’s incorrect. To the best of your ability you can’t tell why it is incorrect. It seems plainly correct. So you tell her so and hope that this will help her feel better about her results. Normally, that would be it, but it just so happens that this mark has caused her to not make honor roll. Blissfully assuming the teacher just made a mistake you call the teacher to see about correcting the error. But you get stonewalled. Eventually you are granted an audience with the principal. You explain the situation, and, to your surprise, the principle replies:

Yes, the answer is correct. But that answer is a fourth-grade answer, and your daughter is only in the second grade. She isn’t supposed to know that yet.

Stunned you say “Excuse me?” The principal continues:

It wouldn’t be fair to the other children if we gave her credit for the answer. You see, you are a devoted couple, married, and you help your daughter study, and there are children in her class whose parents are divorced, or who don’t speak English. Your daughter is ahead of them because you work with her. It wouldn’t be fair to the others if we gave her credit for what she knows as a result of that advantage.

Now, what would you do? For Gregory and Martine Millman, as they recount in their book, Homeschooling: A Family’s Journey, this was their tipping point to take their child out of school and begin an experiment in homeschooling. Their book is part memoir of a homeschooling family and part defense of the legitimacy of homeschooling. They share and reflect on their personal philosophy towards homeschooling, a philosophy that encourages flexibility and spontaneity and that is grounded in the recognition of the importance of the relationship between a student and a teacher.

They spend a considerable portion of the book defending their decision to homeschool their children while also decrying the current state of public schools. As a homeschooling parent, much of this felt like preaching to the choir. But I related quite well to the fact that they continually suffered from doubts as to whether they were doing the right thing, so it is very understandable that they spend so much effort making a case for homeschooling. There also went on a myth busting spree, and there were a few myths that surprised me. For example, they cite studies that show that there is no correlation between expertise in a subject area and the ability to teach it. Another study they cite showed that whether a parent had a teacher’s license or not had no effect on a student’s test score. I looked up that study and found that it also found no correlation in test scores between families that use a “full service” curriculum (this is basically, I gather, a “school in a box” type thing with complete curriculum materials and even scripts for the “teacher”) and those that do not. I found this interesting because when I talk to other people about our decision to homeschool I’m often met with a response like “Oh, I couldn’t do that” and I explain, almost as if I’m making an excuse for myself, that my wife, Tracy, is a former, licensed teacher. But the Millman’s argue, and the studies show, that anyone who wants to homeschool can.

Their philosophy on homeschooling is to create an environment where there is freedom to explore what pique’s the child’s interest. Of course, there is structure, but there is also the flexibility to take advantage of opportunities. For example, they mention a time when some workers came to their house to take away a tree that had fallen down in a storm. Since it was a fairly noisy undertaking, it would have been hard to stick to the schedule. So, they made a learning opportunity out of it. They looked at and noted not only the mechanics of the operation but also the social dynamics of the workers and their boss.

Another important aspect of their philosophy is to provide personal attention and develop the whole child. They place a lot of emphasis on the relationship between the student and the teacher. This relationship is grounded in the practice of emulation; the student emulates the teacher in learning how to learn. The importance of relationship is manifold. For example, there is also the relationship to the subject matter being studied, to really appreciate it for its own sake and not as a means unto an end; in schools, that end is too often a standardized test. They point out that in schools the student learns how to relate to the institution, what its rules are and how to “work the system”, but this kind of relationship is obviously not academically sustaining.

This is not a handbook on how to homeschool; they present a simple homeschooling philosophy that they have developed within their family which they illustrate with several anecdotes. But there is some concrete homeschooling advice. Chapter 3 contains some curriculum advice, materials they have used and found useful, for several academic subjects. But perhaps the most practical chapter is the one on choosing a college. They offer several insights into the admissions process from the perspective of homeschoolers. For example, colleges often require that they have a transcript with grades and such although ultimately they don’t trust the grades reported by homeschooling parents. There’s a list of 18 tips on how to better navigate the admissions process and when our children are reaching that stage of life I know that this chapter will be a handy reference. I also liked how they look at going to college as really “joining” a college, for life and as a family.

Overall, it was a very inspirational book for me as a homeschooler. I was inspired by their adventurous spirit in seeking out educational opportunities wherever they may be. Their holistic approaches to education, their value of developing the whole child, and their emphasis on the importance of relationship have encouraged me to incorporate those same ideas in our own homeschooling.

New Music: Company of Thieves, Matisyahu and more

2009-10-04T08:38:00.005-04:00

I listen to WFPK radio online during the workday and All Songs Considered podcast during my work commute. They have both introduced me to some great music, and here are some of my recent favorites. Hope you enjoy them as much as I did.

Pressure by Company of Thieves

One Day by Matisyahu

Never Forget You by Noisettes

Animal by Miike Snow

40 Day Dream by Edward Sharpe and the Magnetic Zeros

Border Reiver by Mark Knopfler

Combining blogs

2009-06-06T09:24:00.003-04:00

Summary: I'm combining my personal and professional blogs. All my posts will go into this blog. If you only care to get my technology related posts, please update your feed reader to subscribe to just the Technology Related Entries.

A couple of years ago, when I started blogging, I decided (as I had seen others doing) to create two blogs: one for blogging on work related things and one for blogging about everything else in my life. The main reason for having two blogs was so that people who are interested in my technology, work-related writings (i.e., coworkers and colleagues) could subscribe to and receive only those and likewise for my personal blog posts. In the meantime, however, Blogger.com has added the labeling feature which allows me to create feeds of subcategories of this blog.

So going forward every technology related blog post will be tagged with the technology label. I've created a feed just for these posts. Otherwise, if you subscribe to this blog in the normal way, you'll get all entries. Maybe I'll create other feeds for other sub-categories, but for now I'll leave it at

What will I be writing about going forward? Without making any firm commitments, here are some things that I would like to post about in the near term future

Adobe Flex (which I've been learning about and using at my current job)
Homeschooling and parenting
Book and movie reviews and discussions
I've become interested lately in better code design and also software development processes, so I hope to blog on what I've learned and will be learning about these in the future
Python, specifically the TurboGears framework

Your feedback and comments are welcome. Here's to writing more blog posts and writing them more regularly!

How to use custom ant tasks in a WTP generic ant publisher

2008-11-04T20:07:00.000-05:00

Before creating the Eclipse Pluto Server Plug-in, I had an Ant script to publish my portlets to a Pluto server. That Ant script used the Maven2 ant tasks to download the needed Pluto ant task jar and its dependencies. This Pluto ant task is needed to rewrite the portlet's web.xml so that it contains the Pluto server's invoker of the portlet. When I first created the plug-in and needed a way to get the Pluto ant task jar, I looked for how to include it with the plug-in jar but I couldn't figure out how to expose it to the Pluto ant publisher script I created as part of the WTP generic server definition. So, I used the Maven2 stuff I already had, and it worked pretty well for me. However, it was never ideal.

Recently, actually by accident, I figured out how to make ant tasks in a plug-in available to a WTP ant publisher. I stumbled upon the Eclipse ant extension point documentation, specifically, the part about Extra Ant Classpath Entries. Not sure how I missed this before, but it's basically all right there. There's also the org.eclipse.ant.core.antTasks extension point which allows you to expose ant tasks to your ant scripts in Eclipse. Since it wasn't immediately obvious to me at first, I thought I would post how I got it working. It's actually quite simple once you know what extension points to work with.

Here's what I added to the Pluto Server Plug-in plugin.xml to define the Pluto ant task


  <extension point="org.eclipse.ant.core.antTasks">
        <antTask name="pluto.assemble" 
            class="org.apache.pluto.ant.AssembleTask" 
            library="lib/pluto-ant-tasks-1.1.6.jar" 
            eclipseRuntime="false"/>
  </extension>

But of course this ant task has dependencies. To make it's dependencies available to it, you'll just need to add extraClasspathEntries


  <extension
        id="pluto-assembletask-classpath"
        point="org.eclipse.ant.core.extraClasspathEntries">
    <extraClasspathEntries library="lib/castor-1.1.1.jar" eclipseRuntime="false" />
    <extraClasspathEntries library="lib/cglib-full-2.0.2.jar" eclipseRuntime="false" />
    <extraClasspathEntries library="lib/commons-beanutils-1.7.0.jar" eclipseRuntime="false" />
    <extraClasspathEntries library="lib/commons-cli-1.0.jar" eclipseRuntime="false" />
    <extraClasspathEntries library="lib/commons-digester-1.8.jar" eclipseRuntime="false" />
    <extraClasspathEntries library="lib/commons-io-1.3.1.jar" eclipseRuntime="false" />
    <extraClasspathEntries library="lib/commons-lang-1.0.jar" eclipseRuntime="false"/>
    <extraClasspathEntries library="lib/commons-logging-1.0.jar" eclipseRuntime="false"/>
    <extraClasspathEntries library="lib/commons-logging-api-1.1.jar" eclipseRuntime="false"/>
    <extraClasspathEntries library="lib/pluto-descriptor-api-1.1.6.jar" eclipseRuntime="false"/>
    <extraClasspathEntries library="lib/pluto-descriptor-impl-1.1.6.jar" eclipseRuntime="false"/>
    <extraClasspathEntries library="lib/pluto-util-1.1.6.jar" eclipseRuntime="false"/>
    <extraClasspathEntries library="lib/xercesImpl-2.6.2.jar" eclipseRuntime="false"/>
    <extraClasspathEntries library="lib/xmlParserAPIs-2.6.2.jar" eclipseRuntime="false"/>
  </extension>

I'm not quite sure why, but the eclipseRuntime attribute needs to be set to false to get this to work. The docs say

eclipseRuntime - indicates whether this extra classpath entry should only be considered for builds run in the same VM as Eclipse. The implied value is true, when not specified.

So I can only guess that this means that the WTP ant publisher doesn't run in the same VM as Eclipse? Anyhow, I tried it both ways, and it only worked with the value of false.

From my ant publisher script, nothing special, I just reference the pluto.assemble task (I gave it that name). Here's the snippet where I use it:

<target name="assemble" if="portletxml.exists">

<pluto.assemble webxml="${module.dir}/WEB-INF/web.xml"
portletxml="${module.dir}/WEB-INF/portlet.xml"
destfile="${webxml.with.portlet.mapping.file}" />
</target>

Previously I had to define the task with a <taskdef> tag, but I no longer need that.

Pluto Server Plug-in 1st beta of 1.0.0 released

2008-11-04T19:55:00.000-05:00

This past weekend I created a 1.0.0.b1 release of the Eclipse Pluto Server Plug-in. Biggest change is that I got rid of the hack I had in there using Maven to download the Pluto ant task and dependencies needed to publish a portlet to Pluto. I now bundle the ant task jar and its dependencies with the plug-in (a topic for a future post). Having Maven do the download was something that would work most times but had problems. For example, some users have not been able to get the plug-in to work with a proxy server setup (see issue #3).

It likely won't get picked up as an update in Eclipse; you'll need to go into the Update Manager and install it as a new feature. And don't forget to use http://pluto-server-plugin.googlecode.com/svn/trunk/pluto.server.update as your update site. If you try it out, let me know. I'd like to make the 1.0.0 release soon.

Could not publish to server NPE bug fixed!

2008-08-02T18:03:00.000-04:00

I finally had some time to sit down and try to figure out the "Could not publish to server NPE bug". Turns out to be a bug in WTP 2.0.2, bug #219627. The WTP team released a patch and then later they made a full 2.0.3 release. However, if you download the latest version of Eclipse Europa (for JEE), it still has the older 2.0.2 version of WTP. Which I believe explains why there have been so many reports of this problem.

So the fix is to run the update manager in Eclipse and get the most recent updates for WTP. I confirmed this by reverting my Eclipse config to WTP 2.0.2 and was able to reliably reproduce the issue. Reverting back to WTP 2.0.3 got the deploy to Pluto working again.

I added a FAQ page for the project with a FAQ also explaining the issue. I also verified that the Pluto server plug-in works in Ganymede.

Many thanks to campi, by the way. I basically ran a Google search based on the stack trace campi posted to find others who had run into the same issue but with a different plug-in. And that eventually got me to the Eclipse bug and the resolution.

Amazon Unbox Review

2008-06-30T12:20:00.001-04:00

Synopsis: Amazon Unbox is too lacking in the convenience and features departments to justify the price. But if they address some of the missing features and switched to a Netflix-style, all-you-can-eat subscription model, then they could really compete.

Recently had an excuse to try out Amazon Unbox on our Tivo. The whole family was sick this past weekend and we had already watched our Netflix movie and everything Tivo had recorded for us :) So we thought, why not download a movie from Amazon Unbox?

I had already linked my Amazon account with our Tivo account, so ordering the movie just required that I enter a 5 digit pin number. There was a snafu with the credit card I was using, but once I got that resolved, the movie started downloading almost immediately. Only problem was that it took a LOOOONNNNGGGG time for it to download (we have a supposedly 10mbps cable DSL connection). By long, I mean in the range of about 6-8 hours. Since we started this just before dinner, there was no chance we could watch this that night. We had to wait until the next day.

The movie shows up in the Now Playing list as soon as it starts downloading. There is no estimate of how long it will take to complete, but Tivo does tell you how many minutes of the movie have been downloaded. The Amazon Unbox site doesn't tell you how many minutes total the movie is, but I was able to find this information via Netflix. Thus, you can do back of the envelope calculation of how long the download will take. (By the way, I believe the total download size was 2.4 GB).

The way Amazon Unbox works is that you have 24 days to keep the downloaded rental, but once you start watching it, you have 24 hours before it will be deleted. Tivo's provides a warning message when you start watching the movie and if you stop watching Tivo tells you exactly when the movie will be deleted. So that's all very good.

We started watching the movie, and the picture quality is top notch, easily DVD quality. It's just like a recorded TV program; there are no chapters, no menus, just the movie from beginning to end. So that's one strike against Amazon Unbox, that you don't get the bonus features or options or navigability of a DVD. Since the characters in this particular movie speak with a Scottish accent, we wanted to put on subtitles. Nope, can't do it. How about closed captioning? Amazingly, no, closed captioning doesn't work either. This is pretty much a deal breaker for me.

The movie cost $3.99, about the same as rental from a local video store. Is the value worth the price? No, I don't think so. Speaking of the local video store, it would have been faster to have walked to it to rent a DVD, and we would have had a richer viewing experience on top of it, for about the same price. And it can't begin to compete with the tremendous value of the Netflix service.

I have some advice for the Amazon Unbox team (they're waiting with bated breath for it, I know). They really need to add support for closed captioning, at the very least, but if they could figure out a way to add in the other features that one typically expects with a DVD that would definitely bolster their offering. The long download time could be mitigated if the download occurred automatically, in the background. What I'm thinking of here is a subscription service and that one could have a Netflix like queue with their Amazon Unbox account and when they finish with one movie and delete it, the next movie could start downloading immediately. This would mean a turnaround time measured in hours instead of the Netflix turnaround time which is measured in days.

Getting open square bullets in OpenOffice.org

2008-06-28T08:44:00.000-04:00

Sometimes it's nice to create a bulleted list with a check box like bullet, e.g., creating a packing list. Seems like in Word there's a quick option for selecting this style of bullets, but not so in OpenOffice. To change a bulleted list to have a check box style bullet:

Select the bulleted list and in the menu go to Format > Bullets and Numbering...
In the dialog that comes up, select the Options tab.
Click the ... button labeled Character. Under Ubuntu, the default font for my document is DejaVu Sans and the subset of characters displayed is the Geometric Shapes. If you scroll up or down a bit, you can see a few different open square type bullets that can be used as check boxes.

Eclipse Pluto Server Plug-in, v. 0.2.5 (now on Google Code)

2008-06-22T16:07:00.000-04:00

Just finished moving the Pluto Server Plug-in code over to its own project page, pluto-server-plugin, on Google Code. I created a new minor release, v. 0.2.5, just to switch over the update site to the one on Google Code. Switching over a plug-in's update site took some experimentation, but here's how I did it (for future reference and for anyone else needing to change a plug-in's update site)

Change the Update Site URL for the Feature to the new update site.
Bump the Feature version and do a new release to the old site. Users with an older release of the plug-in will get the update which will point them to the new update site for future releases.
Change the Update Site URL in the Update Site's site.xml file. Publish the update site to the new update site location.

So hopefully it will be a seamless update for Pluto Server Plug-in users.

Pluto Server Plug-in: Could not publish to server NPE bug

2008-06-01T15:43:00.000-04:00

Some users of the Pluto server plug-in have had trouble getting a simple plug-in to deploy. They receive an error message:

Could not publish to the server.
java.lang.NullPointerException

Unfortunately, I've not been able to recreate the "Could not publish to the server" error. I have created a new, clean Eclipse workspace and install, and went through the tutorial and it all still works.

For those who are experiencing problems, I've added a test portlet eclipse project that you can import and try to deploy to Pluto. Some other troubleshooting ideas

Make sure that you have a portlet.xml along with your portlet code. That will be necessary. See the eclipse project above for a simple example.
When first doing the deploy, you'll need to be connected to the internet so that the Maven ant tasks can download the pluto dependencies. This is only required the first time you use the plug-in to deploy to a pluto server.
Check ECLIPSE_WORKSPACE/.metadata/.log. It may have more details regarding the exact nature of the error. If you find anything, please do share it with me; I'd love to get to the bottom of this bug.

In other Pluto Server Plug-in related business, I hope to have the code moved over to Google Code sometime this month.

Pluto Server Plug-in Screencast Posted

2007-10-21T07:42:00.000-04:00

Just finished the screencast promised for the Pluto Server Plug-in. It's fairly simple, goes through installing the plug-in and then creating a simple "hello world" type portlet and deploying and displaying it in Pluto.

~~Unfortunately, the size of the screencast, produced with Wink, comes it at a little over 10MB. I need to figure out how to keep these guys from getting so bloated.~~ Using color palette now, has reduced the file size to just under 5MB.

Eclipse Pluto Server Plug-in, v. 0.2.4

2007-09-30T12:09:00.000-04:00

I've been working on an Eclipse Plug-in recently to provide a server definition for the Pluto portal driver. Let me explain why. To start with, I should say that I've been using Pluto 1.1.x with Eclipse for a while, since it comes bundled with Tomcat, it makes a nice, lightweight rapid development environment for working with portlets. And Pluto keeps getting better. In the latest release (v. 1.1.4), changes to the portal pages and layouts are persisted across server restarts.

Alas, there has always been the annoyance that Eclipse wants to deploy your web application as-is to the server, including the web.xml, and Pluto, like all portal servers, expects special servlet mappings to be in place for portlets in your portlet application. For me this has meant having to rewrite the web.xml for when I want to deploy to Pluto in Eclipse, but then changing it back for when I want to change a servlet definition (or deploy to a different portal server, e.g., GridSphere). So that is the problem that this Eclipse plug-in solves. The web.xml rewriting is taken care of by the plug-in at deployment time.

I've put up a quick web page for those interested. For the impatient, create a new remote site in the update manager with this url: http://www.extreme.indiana.edu/~machrist/projects/pluto-server-plugin/updates

I've started work on a screencast to show how this thing works, and hopefully I'll get that posted next week.

PURSe Portlets 1.1.0 Released

2007-07-24T12:23:00.000-04:00

Just finished tagging and releasing a new version of the PURSe Portlets. There are several great things in this release. The one I am most proud of is also the one least apparent to the casual observer: the PURSe portlets are now synced up with the mainline PURSe codebase. In PURSe Portlets 1.0.x, I had made modifications to the PURSe 1.0 release, but now I am a PURSe committer and I've committed some of those modifications and bugfixes into the PURSe trunk. Also, I've developed an install script for PURSe that will install PURSe and it's dependencies, including a minimal deployment of Globus. This should take a lot of the pain out of getting started with PURSe for the new user.

Additional new features include:

Added an AJAX "Check availability of username" to registration portlet
Forgot password portlet now resets the user's password instead of revealing it
Administrative portlet has a paged table of users
Administrative portlet also allows to add a single user or multiple users at once
Portal/portlet "branding" greatly simplified and aligned with PURSe

See the release notes for more information, or the download page to get it now.

Apache MaxClients reached, all connections in CLOSE_WAIT

2007-07-09T08:08:00.001-04:00

Our Extreme Lab web server (Solaris running Apache 1.3) has recently developed a problem. Twice yesterday it got into a state where it had hit its MaxClients limit (of 128, apparently) and then was unable to service any further requests. Running netstat -f inet showed the all existing connections were in the CLOSE_WAIT stage. I can't tell at this stage if there is some denial of service attack going on or just a problem with the server preventing it from finally closing these connections.

Update: Googling around, and with some help from our local Unix guru, Rob Henderson, I found out that if you have connections stuck in the CLOSE_WAIT stage, this usually indicates that the server side is having trouble closing the connection. Rob says that usually when he sees this problem it is because of an NFS server being down. You get requests for something on that NFS mount, and the process hangs there for a long time. With that NFS server remounted, things are much better. Whereas before I was seeing steadily increasing numbers of CLOSE_WAIT connections, I now see none.

JSF Portlet Fun: Request Scoped Beans Don't Survive From Action to Render Phase

2007-06-14T16:58:00.000-04:00

Not sure if this is Pluto specific, but request scoped beans basically don't work as expected since they get initialized on the action phase and then again on the render phase. This is with MyFaces 1.1.4 and Pluto 1.1.3. At least with GridSphere 2.1.5 and MyFaces 1.0.9, I know that request scoped beans do work. See http://issues.apache.org/jira/browse/MYFACES-788 for more information. The workaround is basic and actually standard from the Portlet API point of view. The idea is that for any thing that you want to carry over from the action phase to the render phase, then just add this as a render parameter. In this example, a field of the request scoped bean called "success" is a boolean. So in the action method, I do this:


    // add the success field to a render parameter so it will be available in
    // the render phase.  See constructor as well.
    ExternalContext extContext = FacesContext.getCurrentInstance().getExternalContext();
    if (extContext.getResponse() instanceof ActionResponse) {
        ActionResponse actionResponse = (ActionResponse) extContext.getResponse();
        actionResponse.setRenderParameter("success", Boolean.toString(success));
    }


Then in the contructor for the bean I have:
    // Pull success value from render parameter set in action phase, i.e., submit()
    ExternalContext extContext = facesContext.getExternalContext();
    Map params = extContext.getRequestParameterMap();

    if (params.containsKey("success")) {
        this.success = Boolean.parseBoolean((String)params.get("success"));
    }

TeraGrid 2007, Day 3

2007-06-06T12:44:00.000-04:00

In the Software Provider Forum, I gave a talk on PURSe (using slides provided to me by Rachana Anathakrishnan) and also about the PURSe portlets work I've been doing.

In the presentation I give a sketch of a roadmap for a PURSe portlets 1.1 release, which should be out within a month.

TeraGrid 2007, Day 2

2007-06-06T12:34:00.001-04:00

Stu Martin and I gave a talk on GRAM Auditing and integration of it with the LEAD Portal.

TeraGrid 2007, Day 1

2007-06-05T09:26:00.000-04:00

During most of the first day at TeraGrid 07, I was involved in the TeraGrid Institute tutorial, a kind of "TeraGrid for beginners" tutorial. We did a demo/tutorial using the LEAD Portal as a way of demonstrating how a science gateway can make effective use of TeraGrid, how the sum of TeraGrid is greater than it's individual parts. A screencast we developed in support of the tutorial is available.

Near the end of the day, I had a talk about the LEAD Portal for the "Build your own science gateway" tutorial. It's titled The LEAD Portal: An OGCE based weather science gateway, and you can see it below.

I talked with Kent Milfeld briefly afterward about the difficulty in supporting and managing production and development deployments.

Pluto and creation of UserInfo Map

2007-05-22T15:02:00.001-04:00

Pluto throws a NullPointerException if there is an attribute defined in your portlet.xml that it does not recognize. Happened to me because I generally have the non-standard attribute "user.name" which is the way to get a GridSphere user's username (as opposed to PortletRequest.getRemoteUser()).

Creating a Portlet Preferences JSF VariableResolver

2007-04-19T06:41:00.000-04:00

One of the really cool things about JSF is that just about every piece of it is extensible. One thing I've been playing with recently is the VariableResolver and PropertyResolver parts of the JSF API. I want to create a VariableResolver that is specific to portlet development, so that, for example, when you want to create an EDIT page where a user can specify a preferred nickname, it would look something like this:


 <h:inputText value="#{portletPreferences.nickname}">

And that's it, because custom Variable and Property resolvers take care of the getting and setting for us, no backing beans required.

Turns out this is fairly easy to do. I started with Cagatay Civici's excellent blog/article on creating a custom VariableResolver and PropertyResolver. The first thing to do was to create the VariableResolver. The trick here is that VariableResolvers follow a "Chain of Responsibility" design pattern, and the parent resolver is passed in via the constructor of the child resolver. This is an extremely important point. I rushed ahead on the PortletPreferences part of the variable resolving and forgot to implement the chained part, and you get some interesting results when you do this. Suddenly, your managed beans just silently are unresolvable. No error messages, nothing in the logs, and in fact, it appears at first that they are working, but they do not. So just a heads up, that if you create your own JSF resolvers, do the chaining part first and look out for disappearing managed beans.

So here's how my initial PortletVariableResolver looked:


public class PortletVariableResolver extends VariableResolver {

    private static final org.apache.log4j.Logger log = org.apache.log4j.Logger
            .getLogger(PortletVariableResolver.class);
    
    public static final String PORTLET_PREFERENCES = "portletPreferences";
    private VariableResolver originalResolver;

    public PortletVariableResolver(VariableResolver originalResolver) {
        this.originalResolver = originalResolver;
    }
    @Override
    public Object resolveVariable(FacesContext facesContext, 
                                  String variableName)
            throws EvaluationException {

        try {
            if (PORTLET_PREFERENCES.equals(variableName)) {
                PortletRequest portletRequest = 
                  (PortletRequest)facesContext
                  .getExternalContext().getRequest();
                return portletRequest.getPreferences().getMap();
            }
        } catch (Exception e) {
            throw new EvaluationException(
              "Failed to resolve variable [" + 
               variableName + "]", e);
        }
        return originalResolver.resolveVariable(facesContext, 
           variableName);
    }
}

So here we're resolving the "portletPreferences" variable to the Map of the user's portlet preferences. This is nice, but it only gets you read access to the portlet preferences. For write access as well, we'll need a custom PropertyResolver. First, let's change our variable resolver so that it returns the PortletPreferences object, instead of the map:


            if (PORTLET_PREFERENCES.equals(variableName)) {
                PortletRequest portletRequest = 
                  (PortletRequest)facesContext
                  .getExternalContext().getRequest();
                return portletRequest.getPreferences();
            }

Now for the PropertyResolver.


public class PortletPropertyResolver extends PropertyResolver {

    private static final org.apache.log4j.Logger log = org.apache.log4j.Logger
            .getLogger(PortletPropertyResolver.class);
    
    private PropertyResolver originalPropertyResolver;
    
    public PortletPropertyResolver(PropertyResolver propertyResolver) {
        this.originalPropertyResolver = propertyResolver;
    }
    
    @Override
    public Class getType(Object obj, int index) throws EvaluationException,
            PropertyNotFoundException {
        if (obj instanceof PortletPreferences) {
            throw new PropertyNotFoundException("Cannot reference PortletPreferences by index notation");
        } else {
            return this.originalPropertyResolver.getType(obj, index);
        }
    }

    @Override
    public Class getType(Object obj, Object obj1) throws EvaluationException,
            PropertyNotFoundException {
        if (obj instanceof PortletPreferences) {
            return String.class;
        } else {
            return this.originalPropertyResolver.getType(obj, obj1);
        }
    }

    @Override
    public Object getValue(Object obj, int index) throws EvaluationException,
            PropertyNotFoundException {
        if (obj instanceof PortletPreferences) {
            throw new PropertyNotFoundException("Cannot reference PortletPreferences by index notation");
        } else {
            return this.originalPropertyResolver.getValue(obj, index);
        }
    }

    @Override
    public Object getValue(Object obj, Object obj1)
            throws EvaluationException, PropertyNotFoundException {
        if (obj instanceof PortletPreferences) {
            // TODO: support access to String[] preference values
            PortletPreferences prefs = (PortletPreferences) obj;
            String prefName = (String) obj1;
            return prefs.getValue(prefName, null);
        } else {
            return this.originalPropertyResolver.getValue(obj, obj1);
        }
    }

    @Override
    public boolean isReadOnly(Object obj, int index)
            throws EvaluationException, PropertyNotFoundException {
        if (obj instanceof PortletPreferences) {
            throw new PropertyNotFoundException("Cannot reference PortletPreferences by index notation");
        } else {
            return this.originalPropertyResolver.isReadOnly(obj, index);
        }
    }

    @Override
    public boolean isReadOnly(Object obj, Object obj1)
            throws EvaluationException, PropertyNotFoundException {
        if (obj instanceof PortletPreferences) {
            PortletPreferences prefs = (PortletPreferences) obj;
            String prefName = (String) obj1;
            return prefs.isReadOnly(prefName);
        } else {
            return this.originalPropertyResolver.isReadOnly(obj, obj1);
        }
    }

    @Override
    public void setValue(Object obj, int index, Object obj1)
            throws EvaluationException, PropertyNotFoundException {
        if (obj instanceof PortletPreferences) {
            throw new PropertyNotFoundException("Cannot reference PortletPreferences by index notation");
        } else {
            this.originalPropertyResolver.setValue(obj, index, obj1);
        }

    }

    @Override
    public void setValue(Object obj, Object obj1, Object value)
            throws EvaluationException, PropertyNotFoundException {
        if (obj instanceof PortletPreferences) {
            PortletPreferences prefs = (PortletPreferences) obj;
            String prefName = (String) obj1;
            String prefValue = (String) value;
            try {
                prefs.setValue(prefName, prefValue);
                prefs.store();
            } catch (Exception e) {
                log.error("Unable to set portlet preference [" + prefName + "] to value [" + prefValue + "]", e);
            }
        } else {
            this.originalPropertyResolver.setValue(obj, obj1, value);
        }
    }

}

I've highlighted the main two methods here, getValue and setValue, and I think you'll find them fairly straightforward. The other issue is that we have to implement the array index part of the property resolving, and we just throw an exception in this case (although, as a further exercise, we might want to implement this so that we can reference multi-valued preferences).

At this point, you just need to register the VariableResolver and PropertyResolver in your faces-config.xml file, like so:


  <application>
    <property-resolver>
      resolver.PortletPropertyResolver
    </property-resolver>
    <variable-resolver>
      resolver.PortletVariableResolver
    </variable-resolver>
  </application>

That's it.

Credential renewal with MyProxy and JGlobus

2007-03-29T17:02:00.000-04:00

I'm currently working on create a service as part of the LEAD project that will be responsible for kept grid credentials fresh for the duration of a workflow or some other user process. I've been experimenting with the capabilities of MyProxy and JGlobus to this end.

First of all, the MyProxy site has an excellent page on various grid credential renewal issues and MyProxy. So to begin, I want to set my credential renewer service as a "default renewer" in the MyProxy configuration. I do this by adding


default_renewers "DN of my renewing service"

to the myproxy-server.config file. Now my renewing service can renew credentials stored in this MyProxy server. Next, I store a proxy in MyProxy without a passphrase, so that MyProxy can use it for proxy renewal.


myproxy-init -n -s myproxy-server.mydomain.org -l myusername

The -n option says to store the proxy without a passphrase. Now I can renew this proxy with


myproxy-logon -s myproxy-server.mydomain.org -a /tmp/aging_proxy \
           -l myusername -o /tmp/refreshed_proxy

In the previous command, -a specifies the proxy that we want to renew. For this to work, you either need to have loaded a proxy credential of the renewing service, or you need to set the X509_USER_CERT and X509_USER_KEY environment variables to the locations of the certificate and unencrypted key of your renewing service. And to do MyProxy renewal using the JGlobus API, it looks like this:


MyProxy myproxy = new MyProxy(myproxyHost, myproxyPort);
GetParams getParams = new GetParams();
getParams.setUserName(username);
getParams.setLifetime(24*60*60);
getParams.setAuthzCreds(userCred);

GSSCredential renewedCredential = myproxy.get(serviceCred, getParams);

Note that you need a valid MyProxy username as well as a still valid proxy credential. To load the service credential, do this:


GlobusCredential globusCred = new GlobusCredential(pathToServiceCert,
                                                 pathToServiceKey);
GSSCredential gssCred = new GlobusGSSCredentialImpl(globusCred,
                                GSSCredential.INITIATE_AND_ACCEPT);

An important thing to keep in mind (which I forgot halfway through this process) is that the credential stored in MyProxy cannot have a passphrase protecting it for it to be used to renew a proxy credential. We make use of the grid credential storage feature of MyProxy in the LEAD project, and for this to work with credential renewal, we first have to unencrypt the private key of the grid credential. Use openssl to do this:


openssl rsa -in ~/.globus/userkey.pem -out ~/.globus/userkey1.pem

Then store your credential to MyProxy with this key:


myproxy-store -s myproxy.mydomain.org -l myusername -y .globus/userkey1.pem

Now you'll be able to use this MyProxy credential for proxy renewal.

Setting the var attribute of dataTable in a facelet, part II

2007-03-28T05:42:00.000-04:00

This time I take a completely different approach to this problem. The problem, by the way, is how to apply default Java Portlet API (JSR-168) CSS styles to the dataTable component. As shown in the previous post, this is complicated in Facelets by the fact that we can't just simply pass through a value for the var attribute of the dataTable component. But, this time that won't be an issue because we can simply extend the way Facelets handles the dataTable component and more directly apply the CSS styles we want.

After grepping through the Facelets source code, I discovered that HtmlComponentHandler is the TagHandler associated with the dataTable component (and all other HTML components as well). So I extended this with my own class, HtmlDataTableHandler:


package portletfacelets;

import javax.faces.component.UIComponent;
import javax.faces.component.html.HtmlDataTable;

import com.sun.facelets.FaceletContext;
import com.sun.facelets.tag.jsf.ComponentConfig;
import com.sun.facelets.tag.jsf.html.HtmlComponentHandler;

public class HtmlDataTableHandler extends HtmlComponentHandler {

  public HtmlDataTableHandler(ComponentConfig config) {
      super(config);
  }

  @Override
  protected void onComponentCreated(FaceletContext ctx,
          UIComponent c, UIComponent parent) {
      super.onComponentCreated(ctx, c, parent);
      if (c instanceof HtmlDataTable) {
          HtmlDataTable table = (HtmlDataTable) c;
          if (table.getFooterClass() == null) {
              table.setFooterClass("portlet-section-footer");
          }
          if (table.getHeaderClass() == null) {
              table.setHeaderClass("portlet-section-header");
          }
          if (table.getRowClasses() == null) {
              table.setRowClasses("portlet-section-body," +
              "portlet-section-alternate");
          }
          if (table.getStyleClass() == null) {
              table.setStyleClass("portlet-section-body");
          }
      }
  }

}

I check if the classes are null, to allow the user of the TagHandler to override the styles, but that's about it. The facelets taglib entry looks like this:


 <tag>
   <tag-name>dataTable2</tag-name>
   <component>
     <component-type>javax.faces.HtmlDataTable</component-type>
     <renderer-type>javax.faces.Table</renderer-type>
     <handler-class>portletfacelets.HtmlDataTableHandler</handler-class>
   </component>
 </tag>

I'm not sure which method I prefer, but I'm leaning toward the former, since it seems simpler and I like the idea of keeping things like CSS styles in a template file than in Java code, but in some sense this second approach also seems to be the cleaner one.

Running Portlets on Pluto from within Eclipse

2007-03-28T05:12:00.000-04:00

The Pluto team recently released version 1.1.0 and as part of that release they include a very useful Pluto + Tomcat bundle that makes it very easy to get started. So I've been playing around with this and trying to figure out how to get it to work with Eclipse + WTP, and initially I ran into some issues. By default, WTP wants to take your application server and copy its files to a temporary location in which to deploy your webapp. However, this is fairly disastrous for portlet development because WTP doesn't copy everything and leaves behind important stuff like shared/lib, the portal webapp, etc. So I was trying to figure out what was left behind and manually copying the missing bits into the temporary location... aargh! And then I discovered a nice little feature of WTP. There is this "Run modules directly from the workspace" checkbox in the server settings for your app server, and unchecking this has the effect that Eclipse will deploy your web applications to the location of your app server and not some temporary location! So anyways, here are my notes on how to get this to work.

First, you need to register the Pluto 1.1/Tomcat 5.5.20 bundle with Eclipse as a Tomcat 5.5 server. Select File > New > Other and select Server, then click Next (or, if in the J2EE perspective, right click in the Servers View and select New > Server). Select a server type of "Tomcat v5.5", and click Next. Name it whatever you like, I call mine "Apache Tomcat v5.5 - Pluto". For "Tomcat installation directory:" browse to the location of where you installed the pluto bundle.

Click Finish. Now, we need to modify our Server definition for pluto just a bit, so go to the Servers view (if you don't have it, just switch to the J2EE perspective, or add the view with Window > Show View > Other..., then select Servers). Double click on your Pluto server defined there. Uncheck the "Run modules directly from the workspace" checkbox. We want Eclipse to run Pluto from the location of the pluto-bundle, so that it picks up the pluto webapp, shared/lib, and other bits that are needed because we are working with portlets.

Now, in order to run your portlet in Pluto from within Eclipse using WTP, you need to have your web.xml "pluto-ified". The Pluto guys have an Ant task called "assemble" which can do this for you, that's what I use. Just have it update your web.xml file (probably want to make a backup first). I've been working with a hello-world JSF Facelets sample portlet recently, here's how I get it running in Pluto:

Now we just need to get our application running on Pluto/Tomcat as before (right click on the Project, select Run As > Run on Server). The difference this time is that we will access our application through Pluto. In your web browser, go to http://localhost:8080/pluto. Login as user pluto, password pluto. In the upper left hand corner there is a label called "Navigation:". Mouse over this label to get a popup menu. Then select Pluto Admin from this list. Under Pluto Pages, select Pluto Admin from the drop down list. Then under Portlet Applications, select hello-world-jsf-facelets in the first drop down, and then in the second drop down select HelloWorldSamplePortlet, and click Add Portlet.

Now, the portlet should be there at the bottom of the page.

Note that the portlet pages configuration doesn't persist across restarts of the Pluto server. Consult the Pluto documentation if you want to persist the portal pages layout and configuration.

Now that our portlet is deployed to Pluto from within Eclipse, we can develop our portlet and have the changes immediately reflected in Pluto!

Setting the var attribute of dataTable in a facelet

2007-03-22T06:32:00.000-04:00

I'm currently working on a small little facelets suite to aid in portlet development. Initially, the idea is just to focus on making correct use of the portlet CSS styles implicit. So, for example, the following is the kind of code needed to set the portlet tables styles for the h:dataTable JSF component:


   <h:dataTable value="#{mybean.myData}" var="row"
     styleClass="portlet-section-body"
     rowClasses="portlet-section-body,portlet-section-alternate"
     headerClass="portlet-section-header">

So, I'd like to replace that with a facelet instead, so that it looks like this:


   <p:dataTable value="#{mybean.myData}" var="row">

And the facelet would be defined once in a .xhtml file as:


<ui:composition>
    <h:dataTable value="#{value}" var="#{var}"
      styleClass="portlet-section-body"
      rowClasses="portlet-section-body,portlet-section-alternate"
      headerClass="portlet-section-header">
        <ui:insert />
    </h:dataTable>
</ui:composition>

However, this doesn't quite work. The problem is that it tries to set the var attribute of the dataTable component to a value expression, but dataTable requires a simple string for var. So we have to figure out some way of getting the var variable from the facelet into the dataTable component. What I came up with was a custom TagHandler that evaluates the value expression and then sets the var property of the dataTable component directly:


package portletfacelets;

import java.io.IOException;

import javax.el.ELException;
import javax.faces.FacesException;
import javax.faces.component.UIComponent;
import javax.faces.component.html.HtmlDataTable;

import com.sun.facelets.FaceletContext;
import com.sun.facelets.FaceletException;
import com.sun.facelets.tag.TagAttribute;
import com.sun.facelets.tag.TagConfig;
import com.sun.facelets.tag.TagHandler;

public class SetVarHandler extends TagHandler {

    private final TagAttribute var;

    public SetVarHandler(TagConfig config) {
        super(config);
        this.var = this.getAttribute("var");
    }
    public void apply(FaceletContext ctx, UIComponent parent)
            throws IOException, FacesException, FaceletException, ELException {

        System.out.println("var=" + this.var.getValue(ctx));
        
        if (parent instanceof HtmlDataTable) {
            HtmlDataTable table = (HtmlDataTable) parent;
            table.setVar(this.var.getValue(ctx));
        }
        

        this.nextHandler.apply(ctx, parent);
    }

}

I add this to my facelets taglib.xml file as such:


  <tag>
    <tag-name>setVar</tag-name>
    <handler-class>portletfacelets.SetVarHandler</handler-class>
  </tag>

And then use it like this in my facelet:


<ui:composition>
    <h:dataTable value="#{value}"
      styleClass="portlet-section-body"
      rowClasses="portlet-section-body,portlet-section-alternate"
      headerClass="portlet-section-header">
        <p:setVar var="#{var}" />
        <ui:insert />
    </h:dataTable>
</ui:composition>

Voila! However, seeing as this might come in handy in future instances, I wondered if I couldn't make something a bit more generic. So I created this TagHandler:


package portletfacelets;

import java.io.IOException;
import java.lang.reflect.Method;

import javax.el.ELException;
import javax.faces.FacesException;
import javax.faces.component.UIComponent;

import com.sun.facelets.FaceletContext;
import com.sun.facelets.FaceletException;
import com.sun.facelets.tag.TagAttribute;
import com.sun.facelets.tag.TagConfig;
import com.sun.facelets.tag.TagHandler;

public class SetValueHandler extends TagHandler {

    private final TagAttribute methodName;
    private final TagAttribute value;

    public SetValueHandler(TagConfig config) {
        super(config);
        this.methodName = this.getRequiredAttribute("methodName");
        this.value = this.getRequiredAttribute("value");
    }
    public void apply(FaceletContext ctx, UIComponent parent)
            throws IOException, FacesException, FaceletException, ELException {
        try {
            
            Method m = parent.getClass().getMethod(this.methodName.getValue(ctx), 
                    new Class[]{String.class});
            m.invoke(parent, new Object[]{this.value.getValue(ctx)});
            
        } catch (Exception e) {
            e.printStackTrace();
        }

        this.nextHandler.apply(ctx, parent);
    }

}

So I'm using reflection to call any method on the parent JSF component and passing in the specified value. Then I use it in my facelet like so:


<ui:composition>
    <h:dataTable value="#{value}"
      styleClass="portlet-section-body"
      rowClasses="portlet-section-body,portlet-section-alternate"
      headerClass="portlet-section-header">
        <p:setValue methodName="setVar" value="#{var}" />
        <ui:insert />
    </h:dataTable>
</ui:composition>

There you have it. Turns out there is more than one way to skin this cat, so I'll also share in a future blog post a different approach to this issue.

How to watch Google Videos on your DivX compatible DVD player

2007-03-22T05:44:00.000-04:00

Google has put videos of their Tech Talks series online and I was interested in seeing if I could play these on my SD-3990 Toshiba DVD player which is DivX compatible. All you need to do is:

Find the video at Google Video. Click the download link.
The Google Video Player comes up and starts buffering the video. It saves the video into your My Videos/Google Video directory, or perhaps in a different location, you can check the preferences to see where the location is.
The saved movie file has an extension .gvi (note, this is different than the saved Google Video Player, .gvp, file). Rename the extension to .avi.
Burn this file to a CD-R disc. And it's ready to play.

Last night I used this technique to watch part of Bram Moolenaar's (of Vim fame) talk on 7 Habits For Effective Text Editing 2.0 on my DVD player from the comfort of my living room.

Custom Tomcat Server Location coming in Eclipse WTP 2.0

2007-03-07T06:16:00.000-05:00

Web Tools Platform 2.0 M5 News

This looks very cool (scroll down to "Configure Tomcat's Paths"), especially for us portlet developers. It's been challenging using Eclipse WTP to run and debug portlets because WTP wants to take the Tomcat installation you provide, copy the server parts to a temporary location, and then deploy your webapp there. So it doesn't matter if the Tomcat installation you tell WTP to use has GridSphere or Pluto installed, they won't be there in the temporary location (neither the portal webapps nor shared/lib). Of course, you can manually copy the missing bits into the temp location, restart the server in Eclipse and get something working, but only after much consternation. So I happily welcome this new development and look forward to using WTP 2.0 when a final release is made.

Double Submit Fix with Multiple Submit Buttons

2007-02-20T08:59:00.000-05:00

In the LEAD Portal we have a portlet that allows users to submit weather forecast workflows. When the user clicks the Launch button, a lot of things have to go on behind the scenes to setup and launch the workflow, and it's not atypical for a user to wonder if maybe something is amiss and attempt to click the Launch button again. This double submit is quite problematic for us however.

I searched the web for a double submit prevention JavaScript code, and found some good starts. But our portlet has multiple submit buttons and I found that if I disabled the Launch button after it is clicked, for some reason, that buttons name and value are not passed in the POST to the server. So I have to account for this. Here's the JavaScript I used:


<form action="${actionURL}" method="POST" name="wfParamForm">
<div align="right">
      <input type="submit"
              name="actionMethod_doExp_wiz" value="<>
      <input type="submit"
              name="actionMethod_doExp_wiz" value="Next >" disabled="yes" />
      <input type="submit"
              name="actionMethod_doExp_wiz" value="Cancel" />

      <!-- since we have multiple submit buttons, we need to add the
      name value pair of this submit button to the form action.  It
      seems that when the button is disabled that this also prevents
      it from being present in the POST -->
      <input type="submit"
             name="actionMethod_doExp_wiz" value="Launch"
       onClick="this.disabled=true; this.value='Please wait...'; this.form.action=this.form.action + '&actionMethod_doExp_wiz=Launch'; this.form.submit()" />
</form>

This is from a Velocity Portlet, and it is creating a wizard like interface with Back, Next, Cancel, and Launch buttons on each page of the wizard. Look at the JavaScript for the onClick for the Launch button. Pretty standard stuff (sets the Launch button to disabled, displays "Please wait.." in the button), except that it is also adding the name value pair of the Launch button to the form action. This works and has been tested with IE and Firefox.

Scripting IFrames in IE and Firefox

2007-01-25T15:25:00.000-05:00

Update: Found out Safari requires iframeEl.contentWindow, iframeEl.contentDocument.defaultView doesn't work (or, at least, it doesn't work any more). Turns out that this works for Firefox as well. I've left the other branch for backwards compatibility and also because it is more standard.

Here's how to get a reference to an iframe with JavaScript, in Firefox ~~and IE~~, IE and Safari:


        var iframeEl = document.getElementById("iframeId");
        var iframeDoc = iframeEl.contentDocument
        var iframeWin;
        if (iframeDoc) { // Firefox
            iframeWin = iframeDoc.defaultView
        } else { // IE
            iframeWin = iframeEl.contentWindow
        }
        if (iframeEl.contentWindow) { // IE and Safari require, but works for Firefox too
            iframeWin = iframeEl.contentWindow;
        } else if (iframeEl.contentDocument) { // Works for Firefox, DOM level 2 standard
            iframeWin = iframeEl.contentDocument.defaultView;
        }

And then you can use iframeWin to get access to JavaScript objects and the DOM of the iframe.

Also, I learned that getElementById() in IE (version 7 tested) picks up elements by name attribute as well, so names and ids need to be unique for all elements on a page for IE.

Parenting Hack: Disabling the auto-flushing toilet

2006-12-25T21:52:00.001-05:00

If you are a parent of small children like myself you can probably relate to a situation that I commonly find myself in. I take our 4 year old girl to the public restroom because, well, she's gotta go. And when we get there we see that the toilet is one of those auto-flushing models, you know, with a light sensor that can tell when an adult has sat down and stood back up and hence flushes automatically. I put emphasis on adult because as you may know this doesn't always work so well with a child, especially squirmy ones. Inevitably, the toilet flushes too soon, and these tend to not be wimpy flushers either. The flushing action can remind one of Charlton Heston as Moses in the Ten Commandments parting the Red Sea. And children find this very disturbing, obviously.

Well, on a recent trip to the "facilities", I came up with a simple hack to get around this problem. Simply take a piece of toilet paper (paper towel would probably work well too) and drape it over the light sensor. The child can then safely use the toilet. After the child has dismounted and everyone is ready for a flushing of biblical proportions, remove the toilet paper from the light sensor, which will activate the flushing, and drop it into the toilet.

Happy parenting!

Evaluating Grid Portal Security Paper, Review

2006-12-21T12:39:00.000-05:00

I just finished reading a paper titled Evaluating Grid Portal Security, by David Del Vecchio, Victor Hazelwood and Marty Humphrey. In it they evaluate GridSphere, OGCE and Clarens against a standard set of security metrics. The conclusion is that there is plenty of "room for improvement". I found their recommendation section at the end particularly helpful. It got me to thinking about things we can do in the projects I work with to make grid portals more secure, and here I try to capture my thoughts.

First, I think in the PURSe/PURSe Portlets project, we should provide a way to configure the strength of the password required when a user creates a new registration, and we should provide a secure setting of this by default out of the box. I created a bug report to track this.

Second, I think one of the most difficult challenges for grid portals is in the area of creating, managing and processing auditing logs. But the authors do provide a simple criterion, that all grid credential accesses be written to auditing logs. However, is this sufficient? It would seem that one would need to audit also all grid services requests (e.g., GRAM and GridFTP calls). Then there is the problem of how to audit the auditing logs. Perhaps there are general purpose tools to make this more feasible. Nevertheless, we are seeing in TeraGrid a strong requirement for this functionality, so we need to come up with a solution.

For the LEAD Portal that I work on, this is complicated by the fact that we do not have the user's grid credentials at the portal level, nor do we make calls to grid services from the portal. Ours is a more distributed architecture, with services communicating asynchronously via a publish/subscribe notification broker. So what we need is an auditing notification topic that all LEAD services could write to as a kind of auditing log. A special auditing listener could be set up to listen to this topic and persist the messages to a file or database.

Upgrading MySQL 3.23 to 5.0

2006-12-05T15:43:00.000-05:00

I recently had to upgrade a crufty old MySQL database on one of our Solaris machines (rainier) from 3.23 to 5.0. Here's the process I came up with. This is all in the MySQL documentation, but you have to hunt here and there for it, and what is outlined below allows you to do, or at least, test the upgrade while the original server is still running.

Preparation

Downloaded and installed latest 4.0, 4.1, and 5.0 into a directory.

Copied data directory into /usr/local/mysql-data.

Upgrade from 3.23 to 4.0

Started 4.0 pointing at this data directory, on port 3307.

Edit /usr/local/mysql-data/my.cnf to use port 3307 and socket file /tmp/mysql2.sock

cd mysql-4.0
export PATH=$PWD/bin:$PATH
mysqld_safe --defaults-file=/usr/local/mysql-data/my.cnf --user=emysql --datadir=/usr/local/mysql-data --basedir=$PWD --pid-file=/usr/local/mysql-data/rainier.pid

Check the databases:

mysqlcheck --all-databases -u root -p -h rainier -P 3307

mysql_fix_privilege_tables --user=root --socket=/tmp/mysql2.sock --password=xxxxxx

Lots of warnings and errors, but supposedly this is okay.

Didn't need to upgrade ISAM to MyISAM storage engine.

mysqladmin -u root -P 3307 -p -h rainier shutdown

Upgrading from 4.0 to 4.1.

cd ../mysql-4.1

export PATH=$PWD/bin:$PATH
mysqld_safe --defaults-file=/usr/local/mysql-data/my.cnf --user=emysql --datadir=/usr/local/mysql-data --basedir=$PWD --pid-file=/usr/local/mysql-data/rainier.pid

Check the databases:

mysqlcheck --all-databases -u root -p -h rainier -P 3307

mysql_fix_privilege_tables --user=root --socket=/tmp/mysql2.sock --password=xxxxxx --basedir=$PWD

mysqladmin -u root -P 3307 -p -h rainier shutdown

Upgrading from 4.1 to 5.0

cd ../mysql-5.0

export PATH=$PWD/bin:$PATH
mysqld_safe --defaults-file=/usr/local/mysql-data/my.cnf --user=emysql --datadir=/usr/local/mysql-data --basedir=$PWD --pid-file=/usr/local/mysql-data/rainier.pid

mysql_upgrade didn't seem to work, but I think that's because I had run it in an earlier attempt to upgrade from 3.23 to 5.0. So I did the individual steps:
mysql_fix_privilege_tables --user=root --socket=/tmp/mysql2.sock --password=xxxxxxxxx --basedir=$PWD
mysqlcheck --check-upgrade --all-databases --auto-repair -u root -p -h rainier -P 3307

I ran upgrade again, anyways, this time with the force option
mysql_upgrade -p -S /tmp/mysql2.sock --datadir=/usr/local/mysql-data --basedir=$PWD -u root --force

Additional notes:

Setting up the mysql init script. I set the datadir and the basedir, and then I added a --defaults-extra-file=$datadir/my.cnf to the line that invokes mysqld_safe.

Integrated Google AJAX Search with LEAD Portal

2006-11-28T16:30:00.000-05:00

First I created a LEAD Project custom search engine:

http://www.google.com/coop/cse?cx=001503951656019931001%3Ag2lqfazq_ti

Then I signed up for a Google AJAX search key for portal-dev.leadproject.org. Google gave me some stuff to add, and it worked just fine. I set the web search site restriction to the custom search engine created above:


 var searchOptions = new GsearcherOptions();
 searchOptions.setExpandMode(GSearchControl.EXPAND_MODE_OPEN);

 var leadWebSearch = new GwebSearch();
 leadWebSearch.setSiteRestriction("001503951656019931001:g2lqfazq_ti");
 searchControl.addSearcher(leadWebSearch, searchOptions);

This all worked fairly well, but I wanted a couple of other things from it. First I wanted to have the search control open up the results over the web page instead of within the web page and rearranging the layout. I found this blog entry at www.cjmillisock.com with a nice use of some simple CSS to get the right effect. Secondly, by default the search results are limited to just one. So I created a GsearcherOptions object with expanded mode set to OPEN (see the above code snippet and also the api documentation).

You can see the result at http://portal-dev.leadproject.org

Adding the portlet.xml schema to Eclipse

2006-11-01T09:29:00.000-05:00

Updated 2007-04-12: Fixed the instructions. Seems the old ones don't work any longer.

I finally figured out how to do this. The inferred XML schema support in Eclipse is pretty nice and usually suffices, but sometimes I want to have completion based upon full schema knowledge. Here's how to add the portlet.xml XSD file to Eclipse:

First you need to have the JSR 168 code, so go there and get it.
For Eclipse you'll need WTP installed. Get Eclipse 3.2 and use Callisto Discovery Site to download WTP as well.
Okay, now in Eclipse's preference window, go to Web and XML > XML Catalog. Click Add ....
In the URI field, click the little arrow and select the portlet-app_1_0.xsd file that you downloaded in the JSR 168 release.
In Key Type field select Schema Location. Then in the Key field, enter the schema location that you will be using in your portlet.xml files. I entered http://java.sun.com/xml/ns/portlet/portlet-app_1_0.xsd.
Click OK, OK.
Then you need to make sure you have the following entries in the root element (portlet-app) in your portlet.xml file:

[Added 2007-04-12] xmlns="http://java.sun.com/xml/ns/portlet/portlet-app_1_0.xsd"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
~~xsi:noNamespaceSchemaLocation="http://java.sun.com/xml/ns/portlet"~~
[Updated 2007-04-12] xsi:schemaLocation="http://java.sun.com/xml/ns/portlet/portlet-app_1_0.xsd http://java.sun.com/xml/ns/portlet/portlet-app_1_0.xsd"

Then if you already have a portlet.xml file loaded you'll need to go to XML > Reload Dependencies. Then you should have tag completion in your portlet.xml files.

For more information, here is the corresponding entry from the Eclipse help documentation. I should note that Eclipse seems to think there are errors in the portlet xsd file, but this doesn't seem to cause any problems, i.e., the tag completion works properly.

I should note also that this approach works for other XSD files as well. I recently also used these steps to get schema support for Maven2 pom.xml files.

MyFaces JSF and GridSphere

2006-10-27T16:13:00.000-04:00

Recently I received an email from someone who was trying to create a JSF portlet for GridSphere. This person was looking for some advice. I have only encountered one major problem with developing JSF portlets for GridSphere and that is that in GS 2.1.x MyFaces JSF portlets create invalid default id's for JSF components. The problem is that in this version of GridSphere, RenderResponse.getNamespace() returns an identifier with a "#" character in it, which is an invalid character for JSF component ids. Jason discusses this issue in the gridsphere-dev mailing list.

The simple workaround to this problem is provide id's for each of your JSF components. Here's a snippet of the kind of JSF template that works with GS 2.1.x:



<f:view>
<h:form id="gsid_wrapperForm">
<h:outputtext id="gsid_greetingOT" value="Hello, #{Workspace.userFullName}, you are in your Personal Workspace">
</h:outputtext></h:form></f:view>
...

However, that gets very tedious. Fortunately this problem is fixed in GS 2.2.x, but we're not in a position in the LEAD Project to move to 2.2.x at this time (in fact, I'm holding out for GS 3.0). So I've hacked myfaces 1.1.4 to change the "#" character to "_hash_" when it gets such a value in the returned namespace. The modified jar is available in the Extreme Lab maven repository. Also, if you are using Maven 2, you can use:

<dependency>
<groupId>org.apache.myfaces.core</groupId>
<artifactId>myfaces-impl</artifactId>
<version>1.1.4-gs</version>
</dependency>

to specify the dependency, and you'll need to add the extreme repo in your <repositories> list:

<repository>
<name>Extreme Maven2</name>
<id>extreme.repo.maven2</id>
<url>http://www.extreme.indiana.edu/dist/java-repository</url>
<snapshots>
<updatePolicy>daily</updatePolicy>
</snapshots>
</repository>

This has come in very handy now that I've begun working with Facelets, which I am very happy with.

Using Maven's deploy:deploy-file to import 3rd party jars

2006-10-02T14:18:00.000-04:00

Maven - Guide to deploying 3rd party JARs to remote repository

Usually I just manually copy in third party jars to our Maven repository when they come by, but recently I decided to give Maven's own tools a try. In this example, I'm deploying a MyLEAD jar Scott Jensen has sent my way:


mvn deploy:deploy-file -DgroupId=mylead  -DartifactId=mylead-crosscut-attr \
-Dversion=1.0  -Dpackaging=jar -Dfile=./mylead_crosscut_attr-1.0.jar  \
-Durl=scpexe://rainier.extreme.indiana.edu/l/extreme/java/repository

And here, I deploy it again, but this time as a Maven1 type artifact, to support Maven1 clients:


mvn deploy:deploy-file -DgroupId=mylead  -DartifactId=mylead-crosscut-attr \
-Dversion=1.0  -Dpackaging=jar -Dfile=./mylead_crosscut_attr-1.0.jar  \
-Durl=scpexe://rainier.extreme.indiana.edu/l/extreme/java/repository \
-DrepositoryLayout=legacy

Using service certificates with Globus Java APIs (jglobus)

2006-09-25T16:28:00.000-04:00

Anne Wilson of Unidata recently contacted me about using grid credentials for a long running service. I suggested that she use "service certificates" (definition), but I didn't know exactly how to use them from an application using Java CoG. I looked it up but looks like Anne already has a way to do this or something similar, so I just want to make a quick note about how to do this for future reference.

In jglobus there's the GlobusCredential class. To create a GlobusCredential object from a service certificate (or, more generally, from a certificate/private key pair where the private key is not encrypted), the constructor you use is GlobusCredential(String certFile, String unencryptedKeyFile). From there, it's a little unclear but it seems that you can get a GSSCredential from this by then creating a GlobusGSSCredentialImpl object with the arguments (GlobusCredential, int usage) where it seems a good value for usage would be GSSCredential.INITIATE_AND_ACCEPT.

You would use this approach when you need a service with Globus credentials but you don't want to or can't create a proxy certificate for it over and over again.

Getting commons-logging to behave in Tomcat

2006-09-05T10:39:00.000-04:00

Commons-logging is the bane of my existence, and I only use log4j now in all of my new projects. Unfortunately, I don't have the luxury of completely avoiding it since several projects I depend upon use it. Hence, I've found a simple little way to get commons-logging out of my way when working with web applications in Tomcat. The basis of the trick is to get commons-logging to stop trying to auto-discover the log4j configurations I'm using. So I drop a commons-logging.properties file in the top-level of the classloader hierarchy ($CATALINA_HOME/common/classes) that directs commons-logging to use its own built in SimpleLog facility.


org.apache.commons.logging.Log = org.apache.commons.logging.impl.SimpleLog

Then I add a properties file, simplelog.properties, in the same directory to configure the SimpleLog logger.


org.apache.commons.logging.simplelog.defaultlog=warn
org.apache.commons.logging.simplelog.log.org.apache.myfaces=debug
org.apache.commons.logging.simplelog.log.org.globus.purse=debug

Here I've set MyFaces and PURSe, a Grid security library I use, logging levels to DEBUG. Of course, I have to make sure that I have a commons-logging.jar in common/lib. This setup has been working pretty well for me for some time.

Top 10 Coolest Things coming in JSR 286

2006-09-01T14:06:00.000-04:00

A while back I posted on the availability of JSR 286 Early Draft 1 (just a reminder that today is the last day to get feedback to the JSR 286 group on this early version of the specification). Recently I finished reviewing it and here is a list of what I found to be the most interesting new things coming in JSR 286.

Portlet Events - Yes, they are finally here. Portlets can consume and produce events. This is a very important addition because portals can only handle one action request from one portlet at a time, even though other portlets on the page might want to respond to that action. With JSR 286 they will be able to do this. One thing that is unclear from the specification is the scope of portlet events, i.e., are they broadcasted across all portlets in a page, all portlets within that portlet application, or across all of a user's portlets?
CSS Style Diagrams - Now we can see what the standard CSS portlet styles are supposed to be used for. Okay, it's not a fantastically cool thing, but I'm very happy to see that the JSR 286 group has addressed one of my pet annoyances with JSR 168, that the CSS portlet styles are described only with ambiguous text. And ambiguity makes the standard styles hardly worth the trouble of using, but this is a very important aspect of portability and reusability for Java Portlets.
Shared Session Attributes - Finally, sessions with portal scope! This seems like the most obvious thing to have in a Java Portlet specification I was dismayed to see if missing from JSR 168. One obvious use case for this would be the loading of session objects that other portlets could use for the purpose of "single sign on" in the portal. In the grid portals I've worked with, we load the user's grid proxy credential at log in and need a way to make it available to other portlets. We had resorted to ad hoc singleton style services higher up in the classloader hierarchy in Tomcat. Now we can have a real solution. One interesting point here is that in Early Draft 1, the JSR members specifically ask for input on whether this feature is needed given that you can accomplish the same sort of thing with Portlet Events. It's my opinion that it should be provided, because sometimes you want user attributes in the user's session that aren't necessarily event oriented.
Filters - Like their servlet cousins, portlets now have filters. I've yet to think of a need I have for portlet filters, but now that we'll have them, I'm sure some ideas will come to mind.
Resource Serving - This is a nice feature. This sort of thing is possible in JSR 168 by including servlets with your portlet application that could serve up things like images or JNLP (you know, those WebStart descriptors) documents. But then things were a little bit trickier in that to parameterize those servlet requests you would have to add attributes to the APPLICATION_SCOPE session in your portlet that would later be read by the servlet. Note also that JSR 286 mentions that this would be the way to service AJAX requests.
Use of Annotations - This Java 5 feature is being used to route Event requests to the appropriate event handling method in processEvent(). Oddly, Early Draft 1 doesn't mention that the same will be done for routing action requests to various action methods. I've done this kind of routing in the VelocityPortlet bridge I wrote, using reflection. The annotation idea looks pretty cool and probably cleaner.
More Support for AJAX - The focus of Early Draft 1 is "portlet coordination" and "WSRP 2.0 interoperation", so there isn't much that is AJAX specific here, but we are promised that more is on the way (such as state changing resource serving requests).
Shared Render Parameters - I didn't see this one coming, and I have to admit I'm still trying to figure out how I would best use this. The idea is that when a portlet sets a render parameter this parameter could be shared with other portlets. The outcome of this is that when you select an account to view in the "Accounts List" portlet (invoking a portlet action), the "Accounts List" could set the currently_selected_account render parameter which would cause that account to be highlighted in "Accounts List" (on the render phase). If this render parameter is shared, then the "Account Detail" portlet on the same page could also see this parameter and, since its doView() but not it's processAction() method would be called, it could then update its display with details about that selected account. You can do the same sort of thing with session objects, but this is probably a cleaner way of doing it.
Portlets aren't just for Portals anymore - I love this quote:
The predominant applications using portlets today are portals aggregating the portlet markup into portal pages, but the Java Portlet Specification and portlets itself are not restricted to portals.
With JSR 286, I think Java Portlets have the potential to really remake the Java web development scene. Portlets can and in many cases should be applied to non-portal environment.
JAXB! - Okay, I'm stretching this top ten list a bit. JAXB is leverage in this specification as a way to define payload data for event and shared session attributes. So it looks like I'll need to learn me some JAXB. If you know a good tutorial, let me know.

Fixing Out of Memory Errors with Eclipse 3.2, Mac OS X

2006-08-21T13:56:00.000-04:00

I've recently been getting out of memory errors with Eclipse 3.2 on Mac OS X. Initially, I bumped the maximum heap size to 512MB, but that wasn't sufficient. I then saw that the problem was actually with the PermGen size. So I bumped that up from the default 64MB to 128MB. So far so good.

On OS X, you change these settings by editing Eclipse.app/Contents/MacOS/eclipse.ini. There I set -Xmx to 512m and I added a parameter, -XX:MaxPermSize, and set it to 128m. My complete eclipse.ini file is here:


-vmargs
-Xdock:icon=../Resources/Eclipse.icns
-XstartOnFirstThread
-Xbootclasspath/p:../../../plugins/org.eclipse.jdt.debug_3.2.0.v20060605/jdi.jar-Xms40m
-Xmx512m
-XX:MaxPermSize=128m
-Dorg.eclipse.swt.internal.carbon.smallFonts
-Dorg.eclipse.swt.internal.carbon.noFocusRing

PURSe Portlets v. 1.0.1 released

2006-08-09T14:32:00.000-04:00

PURSe Portlets 1.0.1 Release Notes

Hot off the press, just put this release together. I got a lot of feedback on the 1.0 release, from within the LEAD project and from folks outside the LEAD project. All discovered bugs, more or less, have been fixed in this release. Enjoy!

Lost Production Resumes

2006-08-09T08:49:00.001-04:00

Lost Production Resumes [Sci-Fi Wire]

Lost returns on Wednesday, October 4th!

JSR-286 Portlet - Early Draft Review available now

2006-08-08T09:16:00.000-04:00

JSR-000286 Portlet - Early Draft Review

It's out. Get it, read it, send feedback. I'll be reading through it myself soon and writing about it here on this blog, so stay tuned.

Using Ant with Maven 1 and Maven 2

2006-08-02T17:08:00.000-04:00

I've been using Maven 1 for well over a year now. Not long after I had started using it and generally liking it, the Maven guys decided to drop support for it and came out with 2.0. Everything changed again. This time the directory layout conventions are different (which completes negates the benefits of having adopted a convention in the first place), and it's more difficult now to just use bits of Ant when you need to. I do not look so kindly on such capriciousness; and there are other complaints about Maven besides. Finally, I decided that although like most developers I get more excited about by build tools than I probably should, in the end, it's just a way to build code. Whether it is Ant or Maven, it's really just overhead; at some point, after having constructed beautiful and clean works of code, you need to actually build it and publish an artifact that others can use. And so, in order to lessen this overhead and get some real work done, I decided to move to the more established, more well-known Ant.

However, I now have quite a few projects using Maven 1. And eventually, I'll probably have to co-exist with Maven 2 projects. What's more, I think the best part of Maven is the dependency management; and it gets better in Maven 2 with support for transitive dependencies. Is there a way to have my cake and eat it too? Indeed there is. In a moment of brilliance, the Maven guys decided to take their golden dependency management code and make it available as Ant tasks. Turns out this stuff actually works. I've been able to

use Maven2 to manage dependencies for my Ant builds, with all of their transistive goodness
publish Maven2 artifacts to Maven2 repos
publish Maven1 artifacts to Maven1 repos
use either Maven1 or Maven2 artifacts
treat my Maven repository as both a Maven1 and a Maven2 repository

Getting Started

The documentation on the Antlib for Maven 2.0 page is decent. Installing the Ant tasks is fairly straightforward. You add an XML namespace declaration.

<project name="ExpBuilder" basedir="." artifact="urn:maven-artifact-ant">
...
</project>

Then what I wanted to do was to completely bootstrap the maven dependency by downloading it with the task. For this, I add the following to my "init" target:


<mkdir dir="${lib}/maven" />
<get src="${maven.artifact.ant.url}"
 dest="${lib}/maven/maven-artifact-ant-dep.jar" usetimestamp="true">

<typedef resource="org/apache/maven/artifact/ant/antlib.xml"
     uri="urn:maven-artifact-ant">
<classpath>
 <pathelement location="${lib}/maven/maven-artifact-ant-dep.jar" />
</classpath>
</typedef>

Where ${maven.artifact.ant.url} is defined in the build.properties file and could be a remote url or a local "file:///" url. Some people instead check this jar into CVS along with the code and use Maven to download the other dependencies, but I wanted something completely bootstrapped.

Defining Maven Repos

Here's what I used, again, in my "init" method, to define the needed maven repos. Here's what I have:



<artifact:remoterepository id="extreme.http.maven1"
url="http://www.extreme.indiana.edu/dist/java-repository" layout="legacy" />
<artifact:remoterepository id="extreme.http.maven2"
url="http://www.extreme.indiana.edu/dist/java-repository" />
<artifact:remoterepository id="extreme.scp.maven1"
url="scp://rainier.extreme.indiana.edu/l/extreme/java/repository" layout="legacy" />
<artifact:remoterepository id="extreme.scpexe.maven1"
url="scpexe://rainier.extreme.indiana.edu/l/extreme/java/repository" layout="legacy" />
<artifact:remoterepository id="extreme.scp.maven2"
url="scp://rainier.extreme.indiana.edu/l/extreme/java/repository" />
<artifact:remoterepository id="extreme.scpexe.maven2"
url="scpexe://rainier.extreme.indiana.edu/l/extreme/java/repository" />

Basically I have one maven repository that I define 6 different mappings for. This allows me to treat the same Maven repository as a Maven 1 and a Maven 2 repository. The difference between Maven 1 and Maven 2 repository descriptions is in the layout="legacy" attribute. I started by using the scp:// style remote repository deployment, but found that the scpexe:// style actually works better since it uses my local ssh environment, i.e., it uses my ssh-agent and I don't have to type in my password several times just to publish a single artifact.

Defining Dependencies

This part is where Maven 2 comes in. See the getting started guide for help getting going with Maven 2 if you're unfamiliar with it. Basically I created a very simple pom.xml file that contains only the basic info like groupId, artifactId, version, and then a list of dependencies. The Maven Ant tasks provide a way to read in and reference your POM:

<artifact:pom id="maven.project" file="pom.xml" />

That's it!

Pulling in the Dependencies

One of the "gotchas" I discovered while putting this together was that using these tasks to retrieve artifacts from a Maven 1 repo is time consuming. This is because it tries to retrieve the .pom file for all artifacts, even if the jar in question is already in cache. Since my Maven 1 repository has a lot of artifacts in it that were deployed there with Maven and hence do not have .pom files, Maven spends a lot of extra time trying to download these files (on the order of a minute or two for about 20 dependencies). Hence, I decided to create an Ant target, called maven-dependencies, that would get the dependencies and copy them into ./lib directory. That way I only have to run it occasionally. The downside to this is that I have my compile target, for example, not depending on the maven-dependencies target, but it really should depend on it. Here it is:

<artifact:dependencies pathId="maven.compile.classpath"
                     filesetId="maven.compile.fileset" usescope="compile">
<remoteRepository refid="extreme.http.maven1" />
<remoteRepository refid="extreme.http.maven2" />
<pom refid="maven.project" />
</artifact:dependencies>

<artifact:dependencies pathId="maven.provided.classpath"
                     filesetId="maven.provided.fileset" usescope="provided">
<remoteRepository refid="extreme.http.maven1" />
<remoteRepository refid="extreme.http.maven2" />
<pom refid="maven.project" />
</artifact:dependencies>

<artifact:dependencies pathId="maven.runtime.classpath"
                     filesetId="maven.runtime.fileset" usescope="runtime">
<remoteRepository refid="extreme.http.maven1" />
<remoteRepository refid="extreme.http.maven2" />
<pom refid="maven.project" />
</artifact:dependencies>

<copy todir="${lib}">
<fileset refid="maven.compile.fileset" />
<mapper type="flatten" />
</copy>

<mkdir dir="${lib}/provided"/>
<copy todir="${lib}/provided">
<fileset refid="maven.provided.fileset" />
<mapper type="flatten" />
</copy>

<mkdir dir="${lib}/runtime" />
<copy todir="${lib}/runtime">
<fileset refid="maven.runtime.fileset" />
<mapper type="flatten" />
</copy>

Another gotcha is that although I have dependencies with scope "provided" (more on dependency scope in Maven 2), those dependencies don't get translated into a fileSet or path. The attribute "useScope" here means actually the set of dependencies needed at this scope. So for example my "compile" scoped set of dependencies includes my "provided" scoped dependencies and my "compile" scoped dependencies, since dependencies from both of those scopes are needed to compile my code. Likewise, my "runtime" scoped set of dependencies includes "compile" and "runtime" dependencies since those are needed at runtime (and "provided" dependencies are expected to be, well, provided). I use "./lib/*.jar" as my default classpath in the rest of the build script.

Deploying to Maven 1 and Maven 2 repositories

Again, I wanted to use the same repository for both Maven 1 and Maven 2 style artifacts. Deploying is pretty straightforward; here are my targets:

<target name="maven2-deploy" depends="jar">
<artifact:install-provider artifactId="wagon-ssh-external"
                             version="1.0-alpha-5" />
<artifact:deploy file="${build}/${maven.project.artifactId}-${maven.project.version}.jar">
   <remoteRepository refid="extreme.scpexe.maven2" />
   <pom refid="maven.project" />
</artifact:deploy>
</target>

<target name="maven1-deploy" depends="jar">
<artifact:install-provider artifactId="wagon-ssh-external"
                             version="1.0-alpha-5" />
<artifact:deploy file="${build}/${maven.project.artifactId}-${maven.project.version}.jar">
   <remoteRepository refid="extreme.scpexe.maven1" />
   <pom refid="maven.project" />
</artifact:deploy>
</target>

Again, I'm using scpexe as the install-provider because this picks up my ssh-agent environment on Mac and Linux workstations. On Windows you might want the scp install-provider, although it should be possible to configure scpexe install-provider to use certain executables, such as PuTTY.

Finally, let's build a portlet!

Building a portlet in Maven was pretty easy; just issue "maven war". Okay, well, not that easy, because it probably wouldn't pick up the right things, and if you support deployment to multiple portals, then that typically means you need to have multiple web.xml files. So, here's my war-gridsphere target for creating a portlet war for the GridSphere portal server.

<target name="war-gridsphere" depends="compile" description="Creates a web application resource file">
<war destfile="${build}/${maven.project.artifactId}.war"
   webxml="${webapp}/WEB-INF/web.xml.gridsphere" compress="true">
   <fileset dir="${webapp}" excludes="**/web.xml"/>
   <fileset dir="${src.conf}">
       <include name="*.properties"/>
   </fileset>
   <lib dir="${lib}/runtime" includes="*.jar"/>
   <classes dir="${build}/classes"/>
</war>
</target>

Well, that wasn't so bad.

Portals and Portlets 2006 Conference Recap

2006-07-24T16:16:00.000-04:00

Just got back from a fantastic conference in Edinburgh, Scotland called Portals and Portlets 2006. You can access the presentations given on this page. It was a great time to get together with fellow developers working on portals and portlets and related issues in the Grid community. Of course, Edinburgh is one of the most beautiful places I've been to, and I stayed at the Radisson SAS right along the Royal Mile.

Here are some things that I've been thinking about since the conference, inspired by presentations and discussions I had there:

More than a few times people expressed interest in "portlets without portals". For example, Jason Novotny demonstrated some code he has been working on that would allow bringing a portlet into any web page with just a bit of JavaScript, using AJAX. Previously Jason created the capability to bring a portlet into a JSP page with a custom JSP tag. I've been thinking along these lines as well. It seems the evolution of modern portals, from information aggregators (something akin to a personalized, internet newspaper) to application aggregators to standardized containers, has given us this cool ability to take a web application, treat it like a component, and stick it into a web page. That is, portlets are the cool thing about portals, not the other way around. Portals are now the baggage that portlets have inherited. We now have several portals on the market that do pretty much the same thing, and we inherit their propensity for overbearing layout frameworks that like to cut everything up into rectangle and add lots of icons to them, like "maximize" and "minimize", which I'm pretty sure no user has every seriously used.
The idea I've been toying around with is to take Pluto and wrap it with a custom JSF component, which would be similar to what Jason did with his JSP tag, but I wouldn't need a portal engine, just the portlet container. JSF components are stateful so this component should be able to handle anything that Pluto would normally need a full portal engine to take care of. Couple this with Facelets, and you would have a (nearly) pure XHTML way to create a website, sprinkling in portlets where you see fit.
There was a lot of talk about WSRP. I was unable to find out why anyone would want to use WSRP as it seems to be a solution in search of a problem, but that is just my personal opinion. The consensus of the group seemed to be that WSRP is a good thing to have and that there currently is no decent community (i.e, open source) implementation of WSRP, since the WSRP4J project is still in incubation and it has several bugs besides. Tim Rault-Smith of Sun was there and said that they will be open sourcing the Sun Portal product, including its WSRP stack, so hopefully the community will soon have a decent implementation.
There were several talks about security, which is a difficult problem in Grid environments. Kurt Mueller talked about GAMA 2, which will be available in the next month or so. I talked about my work with the PURSe portlets. Jipu Jiang talked about using Shibboleth with GridSphere. I had a discussion with Tim Rault-Smith about how we are doing authentication and authorization in the LEAD Portal. Our authorization scheme in the LEAD Portal is based on SAML, using these things called capability tokens. What I dislike about them is that they are time-limited just like Globus proxy certificates, and so we run into the same set of issues we experience with proxy certificates; in other words, they are always expiring at the worst moment. What would be nice is either a more lightweight authorization scheme or perhaps if it were possible to grant a capability to a user limited not in time but in "space", that is, limited to only a particular instance of a service, or limited to a single invocation of the service (which of course implies that the service is somehow stateful).
Chuck was there, talking about all things Sakai, and it was good to see him again. He wants to make Sakai a JSR 168 portlet container, and I think that's a great idea. I would love to use Sakai this way, I've never been keen on running Sakai as a separate portal and linking into the LEAD portal via iframes.

Hello World - blogosphere style

2006-07-06T21:41:00.001-04:00

I'm doing all things google today. Created a gmail account, started using the google rss reader, playing with google earth, now a blog. Oh yeah, and then there's this firefox extension that will sync up your firefox settings on multiple computers, called Google Browser Sync. I'll install it on my work computer tomorrow and see how well it works.