I attended two sessions Thursday and both were great. First I attended ‘Demystifying Spring Security in Grails’ by Burt Beckwith. Burt created a few applications with differing security styles using Spring Security. He is a really good presenter who has an obvious understanding of, and passion for, the Groovy/Grails ecosystem. He gave me several additional things to consider when writing applications that use Groovy and Grails.

My final session was ‘Design Patterns in Java and Groovy’ with Venkat Subramaniam. What a session. Venkat is such a great presenter that it’s hard to do him justice in a blog post. He really has a lot of fun and makes the audience have a lot of fun, too. Not only was it really entertaining, but the content was great, too. He spent the session time discussion many of our favorite Java patterns and how they would be implemented in Groovy. It was really nice to see how the code was reduced a significant amount into really concise, expressive statements. I would recommend this session to anyone who has a chance to see it.

All in all, I am very pleased with SpringOne 2GX. It was a great conference. The speakers were great. The content was great. I look forward to attending again.

The first session I attended was ‘Extreme Web Productivity with Spring Roo’ with Stefan Schmidt. I am really interested in Roo. Stefan dived in to some of the web side functionality that Roo offers and I have to say it is pretty compelling.

The next session I attending was ‘RESTing Easy with Grails’ with Andrew Glover. This was a really good session. I liked seeing how Andrew’s take on REST with grails contrasted with his partner at Thirstyhead, Scott Davis.

I then attended ‘Advanced Gorm’ by Burt Beckwith. Wow. What an eye opener. Burt showed how very simple ‘tutorial following’ style of development can get you into some trouble if you don’t understand whats happening under the covers. I took away a few things that I’m going to checkout when I get back to the office to make sure we are doing the best way.

My final two sessions were about plug in development with Graeme Rocher. These were just what I needed to fill a gap I thought existed in Grails – reuse. I knew about the plugin ecosystem, but hadn’t equated it with high level reuse scenarios inside of our company. He explained in detail how plugins work and went on to demo creating a couple of twitter plugins. It was a great session.

Today is the last day and I have a few sessions lined up.

My first session of the day was ‘Clustering a Grails Application for Scalability and Availability’ by Burt Beckwith. This was a good session. It was geared towards Tomcat and MySQL which we are not using, but I still managed to get some good nuggets of information that will, no doubt, prove useful in our Grails endeavors.

My next session was ‘RESTful Grails’ with Scott Davis. I’ve seen several of Scott’s presentations and he never disappoints. He is an energetic and entertaining presenter who is really dynamic and has a great passion for the topics on which he speaks. He laid out some really great stats on RESTful APIs at Google, Amazon, and ebay that really speak to how REST is taking over. I’ll leave it to him to detail the stats.

Lunch was great. NFJS has some killer meals and today was no exception. We had some good lunch conversations with others who seemed to work for organizations very similar to the one we work for. I’ve found that most of the people I’ve talked to work for organizations in really similar Spring/Groovy/Grails adoption modes to ours. It’s nice to know we’re not alone in our discovery and struggles.

After lunch I hit the ‘Whats new in SpringSource Tool Suite’ session. This was a good session. The speaker, Christian Dupuis, talked a lot about STS’s integration with Spring 3.0 and the capabilities STS will have as far as code completion and validation.

After much anticipation I got introduced to Spring Roo in the ‘Introducing Spring Roo: Extreme Productivity in 10 Minutes’ session by Ben Alex. He did a great job giving a high level overview of Spring Roo and setting up the follow up session that will give a more in-depth view of Spring Roo. I have to say that Spring Roo is impressive. I like the loose parallels with Grails without the runtime penalties (although I’m a Grails guy). He explained how it makes sense how they both fit in the landscape without really competing. I can say that I will definitely look to use Roo on future projects where we can’t/don’t use Grails. I’ll be doing some playing around with Roo over the next few weeks.

The last session I attended today was ‘Grails for the Enterprise’ by Robert Fischer. This was billed as an introduction to Grails, which I didn’t need, but I went anyways. And I’m glad I did. Robert gave an overview of the case for Grails with some emphasis on the parts/plugins he knew well because he had either created or contributed to them. When the open questions part of the session came, Robert did a 5 minute demo on creating a plugin that, if there wasn’t already enough reason, made the whole session worthwhile for me. It was a great session for me… the kind where you get an answer to a question or two that almost makes the cost of attending the conference worth it.

After all of the sessions, dinner was served and a keynote ensued. After the keynote speech, another reception took place where I got to mingle with some more good folks.

It was definitely a great conference day. I’m looking forward to tomorrow.

Rod talked about the @Configuration annotation in Spring 3.0 that I think is awesome. Basically we can use annotations to specify a configuration class that can also use normal injection to load its dependencies and properties. Should make for much more flexible Spring config and less XML Hell.

Rod introduced Spring Integration and Blaze DS (Spring/Flex integration) and had a few SpringSource guys do a demo. It went over pretty well.

Graeme Rocher took the stage to talk about Grails. This was my favorite part. Graeme did a demo of the Grails support in the upcoming (Wednesday) STS release which showed some awesome Grails integration. I will definitely find out about debugger support while I’m here as that is my big Grails hangup right now. He also mentioned Intellij Community Edition, which I had no ‘idea’ about. I will definitely be checking into it. He also talked about the Grails community… high points being that there are over 300 plugins. He joked with an Apple-like “…there’s a plugin for that”.

Rod made an announcement about SpringSource TC Server Developer Edition which is 100% Tomcat, is Spring aware, and offers the Spring insight dashboard.

We were then treated to some STS integration with tools that have evolved from the Hyperic acquisition. They offer awesome looking performance evaluation capabilities. They are hoping to be available by year end.

Finally Rod talked about the VMWare acquisition. Obviously he thinks and hopes it leads to greater things for Spring, Groovy, and Grails in the future, in particular to cloud computing.

All in all, I am really excited to attend the sessions I have chosen so far and am looking forward to being immersed in the Spring and 2GX universe for the next 3 days.

I hadn’t used JRuby before, but had always wanted to mess with it. Celerity uses JRuby so I had my excuse. It only took a couple of hours to have a fully functional test case running. I used a ‘load test’ Ruby script I was using with Watir to run concurrent instances of the test case. With a single thread everything was excellent. But even just going to 2 threads caused the process to fail with an OutOfMemoryError. I tried increasing the heap size using the
-J-Xmx###m
option, but it didn’t help. Luckily, my twitter on the subject was replied to by ‘@jarib’ who helpfully pointed out that the error was a PERM GEN issue rather than a plain ol’ heap space issue. The solution was to use
-J-XX:MaxPermSize=256m
as the option. After doing that I could run 7 threads, enough to severely slow down my system, but still work without memory issues.

I’m definitely a fan of Celerity now, and I’d recommend anyone interested in web application testing look into it.

Here’s a screenshot of the project dashboard.

I have run Cobertura and PMD against the codebase of this project before, but seeing all of the result together gives you a great, and possibly alarming, view of the quality of the code.  At first CheckStyle was really ticked off.  I was using the default module set that was included in the CheckStyle distribution (sun-checks.xml) and it was enforcing some rules that I don’t agree with as important and wouldn’t ask my team to worry about either… most of them were in the ‘Whitespace’ category (I’m not arguing their merit, just saying we aren’t following them now).  After I tweaked the modules that were being used it was much happier, but still showing some issues we need to work on.

The visibility tools like these give you are great… and it couldn’t be much simpler.  Now we’re going to be able to enforce unit test code coverage, style, and complexity rules easily and actually measure project performance with these metrics as well.  I will be checking into a lava lamp soon.  

I know there are commercial tools for this sort of thing, too, but Hudson is a great open source tool.  Thanks to those involved in its development.  Thinking back to my early years when there wasn’t ‘open source’, only ‘freeware’, I can’t imagine tools like this being openly available.  How far we’ve come.

This is a good way for our team to start the new year. 

Happy New Year to you.

Some Background: We’re going to offer an e-bill presentment application for our local companies’ end customers to use to view their invoices online. As mentioned above, we contracted with a software development firm to write the application for us since we have limited resources and wanted to get this out ASAP. Our contract basically has the contractors handing us WAR files as the deliverable so we have a lot of responsibility to test and assign issues to them. Since we don’t have a server administrator I get to play that role. Being the technical lead of the group who is responsible for the application I wanted to run it through it’s paces on our new Application Server infrastructure to do some load tests.

My tool of choice was JMeter because I have used it before and found it good at cranking up pure traffic to see how the servers would handle it. As a matter of fact, when we deployed our WebSphere Portal cluster close to two years ago we managed to put a hurting on our big-iron ERP system while load testing the cluster using JMeter. I tried using JMeter’s proxy to generate some tests but kept having issues with the login. Not being familiar with the application or RichFaces, I am having issues figuring out how to get JMeter to recognize session indicators and using them rather than sending ‘recorded’ traffic.

For speeds sake, I decided to look into alternative testing methods. I knew if I could do actual ‘click’ testing where it was more of a user gesture recording than pure network traffic recording I’d probably have better luck, at the expense of not being able to generate as much load.

I started with Selenium. It’s super simple and ultimately I bet it will work well. Unfortunately, I had some problems with the login again. If I manually logged in using the browser then ran the Selenium scripts it worked great. That wasn’t an option – how could we load test if a human had to get the login part over? I’m betting I’ll be able to get into the selenium scripts and/or APIs and get it to work well too, but I was in more of a ‘spike’ mode so I wanted to go with multiple options rather than spend a whole lot of time on a single option.

Enter Watir. I dig Watir. I have only toyed with Ruby, but now I can see myself using it regularly, if only for use with Watir. I downloaded the Watir examples and within an hour was ‘load testing’ the application – al least to the degree that one laptop can run Internet Explorer multiple times. I’d love to see something like this that could interpret the DOM without actually having to show the UI, but since I’m not working on a solution for it I’m not going to complain about it.

Since I have a solution using Watir (even if I have to fire it up on 5 or 6 computers simultaneously) I’m going to reverse course and head back to Selenium to see if I can get the login to work. If I can, then I’ll need to get something that’ll allow me to run the scripts in a multithreaded way to do the load part of load testing, but I suspect there’s already something like that for Selenium.

After a few hours of discovering this issue and looking into it, I found a simple work around, which was to set the hibernate property ‘hibernate.connection.isolation’ to 0 using the following XML in the config file:

<property name="hibernate.connection.isolation">0</property>

The problem for me arose when I needed to write applications using a shared connection coming from a WebSphere DataSource. I couldn’t find a way to tell the WebSphere DataSource to use the transaction isolation level of ’0′ or ‘NONE’. There were a couple of things I found that seemed to indicate a way, but none of them worked. I had to suck it up and just write SQL for simple CRUD operations.

Since I took a job at that company, it has affected me in a more cumulative way. Most of the java apps we write are for WebSphere AS or WebSphere Portal, both of which can and should use WebSphere datasources. I knew that if I didn’t solve this problem, the team would spend a whole lot of time writing CRUD SQL and incur the expense of the time writing the SQL, the expense of fixing the errors introduced writing the SQL, and not be able to take advantage of the simplicity provided by using an ORM framework like Hibernate. So on my latest project I made it a priority to solve this problem. I first started with talking with some folks about getting journaling enabled on the DB2/400 files I was working with. After a few minutes of this conversation I decided it’d be better to make use of the ‘open’ part of the ‘open source’ code base of hibernate. After a few hours of internet research of this issue and looking at some of the Hibernate source I figured if I could just set the ‘autoCommit’ property of the javax.sql.Connection to true and set the transactionIsolation level to ‘NONE’ (or 0 if you’re into literal values) then I’d be set. I tested this by hacking into the actual connection object Hibernate was using right before my SQL statement executions. It worked so I was happy, but I didnt want us to have to do this ‘HACK’ everytime we wanted to use Hibernate with a DB2/400 data source. So I started looking at other ways. I found one.

The default WebSphere DataSource Helper for the iSeries Toolbox is the class com.winwholesale.db2400.hibernate.DB2AS400DataStoreHelper. After looking around enough I found that there were a few methods on the ‘helper’ that could allow me to solve our problem. First was the method that showed that the helper was actually the class that indicated the transaction isolation level, called (interesting enough) getIsolationLevel. I created a new DataSource Helper class that extends the normal AS400 one and returned: javax.sql.Connection.TRANSACTION_NONE
This accomplished half of what I needed, but I still had to deal with setting the autoCommit property to true. The helper made it simple to set this. It has a method called doConnectionSetup that allows you to do whatever you want to the connection before it’s used. So I added my autoCommit assignment there. Here is the total code of our new helper class:


import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;import javax.resource.ResourceException;import com.ibm.websphere.appprofile.accessintent.AccessIntent;
import com.ibm.websphere.rsadapter.DB2AS400DataStoreHelper;public class DB2400HibernateDSHelper extends DB2AS400DataStoreHelper {public DB2400HibernateDSHelper( Properties props){
super(props);
}public void doConnectionSetup(Connection connection) throws SQLException {
super.doConnectionSetup(connection);
connection.setAutoCommit( true );
}
public int getIsolationLevel(AccessIntent arg0) throws ResourceException {
return Connection.TRANSACTION_NONE;
}
}As you can see, it is very simple.

I’d like for us to decide on a single one, but we have no limitation on using just one.  The choices we have in front of us are the usual suspects: GlassFish, Geronimo, and JBoss.  I’m not deeply familiar with any of them – but I am a somewhat familiar with Geronimo.  I have messed with it most, having hosted my old home website (before the blog) on it for a while and having been a tomcat user for years.  I have messed with both GlassFish and JBoss too, but in a much smaller way.  I’m probably leaning towards Glassfish right now.  I like what I’m reading about it and it’s been pretty easy to get up and running.

There are a lot of posts and articles about this subject so I’ll have no shortage of opinions.  It doesnt appear that any one of these application servers has distanced itself from the rest of the pack.  They are all three strong competitors so I doubt we can go wrong no matter which one(s) we choose to use.  It should be a fun process.