Cameron Stokes’s Blog

I consider myself a very focused and productive person, but over the past couple of weeks I’ve realized that I am much more productive when working from a task list.  The list keeps my mind from wondering to other tasks and I get a great satisfaction in checking tasks off and reviewing the list at the end of the day to see what I have accomplished.  I have some ideas on how to improve my list (and digitize it); let’s see how much more productive I can get!

This week’s task list:

This week's task list

Working on my latest project the past couple days I was trying to figure out a way to enforce authentication for some requests but not others.  I first wrote a Filter but when I started mapping the filter to my specific URLs I realized how tedious this could become.  I then remembered that Spring allowed for interceptors in its web framework and after a quick glance through their documentation I found the section I was looking for.  Unfortunately this still wasn’t exactly what I needed as Spring applies your interceptors to all requests configured in your handler mapping.  Looking at the HandlerInterceptor API I found I had access to the handler that was being processed and I just needed to decorate my handlers that needed authentication and adjust my interceptor to first check the handler.  I decided to create an empty Interface named AuthenticatedController which my controllers could implement to indicate they needed to be protected from unauthenticated access.  You could also do this using annotations, but here’s my code:

AuthenticatedController.java

public interface AuthenticatedController {
    // This is empty on purpose.
}

SimpleController.java

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;

public class StateController implements AuthenticatedController {

    public ModelAndView handleRequest( final HttpServletRequest httpServletRequest,
            final HttpServletResponse httpServletResponse ) throws Exception {
        ...
    }

}

AuthenticationInterceptor.java

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

public class AuthenticationInterceptor extends HandlerInterceptorAdapter {

    public boolean preHandle( HttpServletRequest request, HttpServletResponse response,
            Object handler ) throws Exception {

        if ( !( handler instanceof AuthenticatedController ) ) {
            // Authentication not needed, allow request to continue.
            return true;
        }

        boolean isAuthenticated = checkAuthentication(...);

        if ( !isAuthenticated ) {
            // User is not authenticated, handle response as needed, and halt processing.
            response.setStatus( HttpServletResponse.SC_FORBIDDEN );
            return false;
        }

        // User is authenticated, allow request to continue.
        return true;
    }
}

spring-beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

<bean name="authenticationInterceptor" class="custom.AuthenticationInterceptor" />

<bean name="urlMapping"
    class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="interceptors">
         <list>
	     <ref bean="authenticationInterceptor" />
	</list>
    </property>
    <property name="mappings">
	<props>
            <prop key="/controller1.json">controller1</prop>
            <prop key="/controller2.json">controller2</prop>
            <prop key="/controller3.json">controller3</prop>
        </props>
    </property>
</bean>

</beans>

At work we use a combination of Subversion (svn), Maven, and Ant to build and deploy our applications and integrate the svn revision number into our deployment packages.  As an example, if we’re packaging our callcenter application our build scripts will create a callcenter-7175.jar package.  This makes it easy for us to upgrade and rollback between versions as needed.

The svnversion program makes it easy to get the revision number of your working copy by simply executing the program:

macbookpro:rel-091105 stokesc$ svnversion
7175

To use this from Ant we can use the exec task. The example below will execute svnversion and capture its output into the Ant property repository.revision which is used later on in our build script:

<?xml version="1.0" encoding="ISO-8859-1"?>
<project name="Build Script" default="make" basedir=".">

    <target name="make">

        <!-- Get current working directory. -->
        <exec executable="pwd" outputproperty="dir.root" />

        <!-- Get subversion revision number. -->
        <exec executable="svnversion" outputproperty="repository.revision" />

        <echo message="Repository revision is ${repository.revision}" />

    </target>

</project>

This worked well for us for a few years but when we needed to build from an older branch the revision number wasn’t representative of the last revision in the branch.  Looking at the options for svnversion I found passing -c will return the revision number of the last change rather than the current revision which is what we really wanted.

macbookpro:rel-091105 stokesc$ svnversion -c
1:6985

You can see the difference in revision numbers from this command versus the one above, but this still isn’t perfect due to the starting revision number that’s been added.  A little change to our Ant script can strip this off for us.  Here we use the redirector and filterchain types and a regular expression to modify the output.

<?xml version="1.0" encoding="ISO-8859-1"?>
<project name="Build Script" default="make" basedir=".">

    <target name="make">

        <!-- Get current working directory. -->
        <exec executable="pwd" outputproperty="dir.root" />

        <!-- Get subversion revision number. -->
        <exec executable="svnversion" outputproperty="repository.revision">
            <!-- Specify '-c' to get last changed rather than current revisions. -->
            <arg value="-c" />
            <!-- Use redirector/filterchain to parse output.
                 svnversion -c will return output in format [initial]:[current]
                 and we want to strip off [initial]: -->
            <redirector>
                <outputfilterchain>
                    <tokenfilter>
                        <replaceregex pattern="[0-9]+\:" replace="" />
                    </tokenfilter>
                </outputfilterchain>
            </redirector>
        </exec>

        <echo message="Repository revision is ${repository.revision}" />

    </target>

</project>

We’re now able to go back and package older versions of our application with a true indication of their svn revision.

This past week has been a great beer week.  Last Tuesday we had dinner at the Westside location 5 Seasons Brewing Company and enjoyed their beer sampler along with some great food.  Each of their beers was delicious, especially their IPA.  This was only the second time I’ve been to 5 Seasons; the first being at the Prado location where Kevin McNerney brews, of Sweetwater fame.

Last weekend we made our way down to Tampa for the ACC Championship Game (go Tech!) and made sure to take advantage of the beers available in Florida and Tampa specifically that we can’t get in Georgia.  Friday night, we grabbed dinner at the Tampa Bay Brewing Company and had great beers and great food.  Again I got their beer sampler which included each of their year-round beers and a cask-conditioned Moosekiller Barleywine; all very delicious.  I highly recommend Tampa Bay Brewing Company; in addition to the beer and food, the service was excellent.  Before the game on Saturday we stopped by a Total Wine and stocked up on the infamous Dogfish Head 120 Minute IPA as well as Dogfish Head’s Shelter Pale Ale, Raison d’Extra, Fort, and Theobroma, Cigar City Brewing’s General Zhukov’s Imperial Stout and Improvisacion Ale, and Lazy Magnolia’s Southern Pecan and Indian Summer.  I’ve since tried a 120 Minute IPA but haven’t made it to the others yet.  I had to reorganize the beer fridge in order to fit everything.  Here’s the full score from Florida:

Score from Florida

Back in Georgia, Terrapin has released their Hopsecutioner IPA.  I am a total hophead and this beer does not disappoint.  I’m actually quite proud of myself as this is the first beer I’ve successfully identified a hop in the beer by taste alone.  A couple weeks ago I had Rogue’s Yellow Snow IPA and remarked how different the hop profile was from a typical IPA.  I can taste the same hop in the Hopsecutioner: Amarillo.  I’ve yet to make a homebrew using this hop, but this has moved up the list on things to try.  I love the flavor of this hop.

If only more weeks could be like this…