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:

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.

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.