Lots of our customers are “Microsoft Shops” from soup to nuts – SQL Server, Active Directory, Internet Explorer – you know the drill. So we’ve been working hard to make our Grails-based offering run just lovely alongside existing Enterprise apps.

Grails and SQL Server

First things first, we’ll need a SQL Server JDBC driver so we can play nice with common SQL Server versions (viz. 2005/2008R2). We evaluated a couple of Microsoft SQL Drivers including: the Microsoft One, and the jTDS one. Both worked fine, but we ended up going with the jTDS one since it seemed faster in our smoke testing. And it was in a Maven repo.

jTDS DataSource Configuration

We experimented for this for for quite some time to get everything just so, so I’d thought I’d take some notes for you to to lean on. First of all, if you’re going dataSource config, you’ll want something like this:

dataSource {
	pooled = true
	dialect = org.hibernate.dialect.SQLServer2008Dialect
	driverClassName = "net.sourceforge.jtds.jdbcx.JtdsDataSource"
	url = "jdbc:jtds:sqlserver://yourhost:1433/GMARC;useNTLMv2=true;domain=yourDomain"
	dbCreate = "none"
}

There are some excellent docs on the URL Formats for jTDS but I found the useNTLMv2 switch was essential in the client’s environment. Apparently v1 (the default) is full of security holes, and there are standard NT group policies that disable NTLMv1 entirely. I also found that the domain switch needed to be provided otherwise we were hosed.

Going Managed

If you’re walking the Tomcat-managed DataSource, you’ll need to use the matching context.xml version of the above:

<Resource name="jdbc/gmarc" auth="Container" type="javax.sql.DataSource"
        driverClassName="net.sourceforge.jtds.jdbc.Driver"
        url="jdbc:jtds:sqlserver://yourhost:1433/GMARC;useNTLMv2=true;domain=yourDomain"
        maxActive="20"
        maxIdle="10"
    	validationQuery="select 1" />

Then, of course, you’ll make your configuration datasource of the JNDI variety… Perhaps something like

dataSource {
    jndiName = "java:comp/env/jdbc/gmarc"
}

One of the advantages of using the Container-managed variety of DataSources is that you can run somethink like PSI-Probe (a fork of the old Lambda probe) to validate your data source connections without going anywhere near your Grails config. Useful stuff. We’ll do more of that.

A Note on SQL Server Port Weirdness

If you’ve had a few SQL Server installs concurrent on your Dev box, the SQL port will move off the standard 1433 and onto some random port. We’ve had issues on our dev machines with this one, so head in the SQL Server Config Manager, have a look at the Network Configuration/Protocols/TCPIP then scroll to the bottom of the IP Address and find the TCP Dynamic Ports setting you need. What a snack

Integrated Security & Sticking Files Where They Belong

You’ll notice neither of the above has username or passwords. Most SQL Server Admins despise Mixed Mode security (where you setup special usernames and passwords inside SQL Server itself). Microsoft has gone to the trouble of writing security white papers telling you to turn off Mixed Mode, so Integrated Security is your best friend in most MS enterprise shops.

With Integrated Security, you run your Tomcat service as a Active Directory Domain Account, then your credentials are remoted to SQL Server automatically. To get jTDS to work that way, you’ll want to make sure that you have place the DLL that ships with the driver in the right spot.

You’ll want to dump your jtds-1.2.5.jar file into <TOMCAT_HOME>/lib, but if you want to use Integrated Security, you’ll need to put that ntlmauth.dll file somewhere too. It has to be somewhere in your Windows path (we normally use Windows\system32), but you can happily put it into <TOMCAT_HOME>/bin and it seems to find it.

Word to the Wise: You need to match the right version of the DLL to your target operating system. I foolishly copied the 32bit version of the DLL onto a 64bit Windows install and wondered why I didn’t get a connection (nor did I get an error message that helped me out, so be warned).

Further Word to the Wise: We had to run the Tomcat service using the “@” format of domain account. So instead of “yourDomain\yourAccount”, we ran the service as “yourAccount@yourDomain”. Didn’t even know that worked! I’m such a MS noob these days..

Enough SQL Config. It’s time to have a look at AD integration.

Grails & Active Directory

Given that we’re using the amazing Spring Security plugin for Auth, it was a  no-brainer to head down the Spring Security LDAP plugin path and tune things for Active Directory. Our config is pretty vanilla per the sample docs, but we externalise it so we can tune it after deployment:

// Turn this switch on to enable Active Directory/LDAP Integration
grails.plugins.springsecurity.ldap.active = false

// LDAP config
// In particular, the Admin Account is only required to located the full DN of the user within the search base.
// Once that's found you can just bind as the real user.
grails.plugins.springsecurity.ldap.context.managerDn = 'CN=LdapSearchAccount,OU=My Users,DC=bytecode,DC=com,DC=au'
grails.plugins.springsecurity.ldap.context.managerPassword = 'yourClearTextPasswords'

// User-specific LDAP Configuration
grails.plugins.springsecurity.ldap.context.server = 'ldap://dir1.bytecode.com.au:389/'
grails.plugins.springsecurity.ldap.authorities.ignorePartialResultException = true // typically needed for Active Directory
grails.plugins.springsecurity.ldap.search.base = 'OU=My Users,DC=bytecode,DC=com,DC=au'
grails.plugins.springsecurity.ldap.search.filter="sAMAccountName={0}" // for Active Directory you need this
grails.plugins.springsecurity.ldap.search.searchSubtree = true
grails.plugins.springsecurity.ldap.auth.hideUserNotFoundExceptions = false

// Role-specific LDAP config
grails.plugins.springsecurity.ldap.useRememberMe = false
grails.plugins.springsecurity.ldap.authorities.retrieveGroupRoles = true
grails.plugins.springsecurity.ldap.authorities.groupSearchBase ='OU=My Groups,DC=bytecode,DC=com,DC=au'
grails.plugins.springsecurity.ldap.authorities.groupSearchFilter = 'member={0}'

Determining DNs

We found that getting the right DNs for Groups and Users was a bit of a pain. Lots of the samples use CNs for the different containers, but in the wild we have found that OUs rule the roost.  We found that Microsoft’s AD Explorer tool was a good way to work our the correct DN for the containers for users and groups (spaces in names seem to work fine too – yah!).

Our only snag was that cleartext manager password. I should get motivated and write a patch for that (following the same patterns as the encrypted datastore passwords).

We use AD-based ROLES for all our app-based security stuff. Creating groups in Active Directory called “GMARC_Admin” will result in the mapping becoming ROLE_GMARC_ADMIN once the user authenticates, which makes sense, so cater for that in your mapping. We ended up using DB-based security mapping rules so we can reconfigure the app’s security after deployment. Turns out that was a good decision!

What about Browser-based SSO?

We’ve been toying with the idea of a full SPNEGO/Kerberos SSO deal, but have yet to make that leap. For starters, our clients were happy enough to be able to login to our app using their username/passwords (this is going to be a problem down the track for agencies that use some kind of token-based logon, so we’ll probably go full-on Kerberos in our next major rev and deal with the browser-fallout when it happens!).

How’s it working out for you?

Once we’d shaken down the basic config problems, and come up with some diagnostic tools, we’ve been pretty happy with the result. SQL Server seems to perform pretty snappily. And Tomcat runs just great on Windows. Only only big hurdle left is a nice Windows-based installer. Sounds like a 1.1.x feature

Here’s my stab at the tech areas I’m interested in getting across in 2012:

• Grails 2.0 Deep Dive. Grails In Action has a completed TOC and a slated release schedule for 2nd Edition. So I guess most of the hard work is already done No doubt there will be many adventures posted here in the days to come.
• GUI Applications. I know everyone is giddy with mobile at the moment and I spent plenty of time building mobile apps for every possible device on a project last year. This year I’ve ended up with a couple of major Swing gigs on the timeline, so this is a great chance to catch up on Frankenstein GUI skills (for all platforms, not just Swing). Native Android might be a good experiment area here too. And Griffon goes without saying. It’s much harder when you don’t have a “Twitter Bootstrap” for Native GUIs!
• Integration Testing. I’ve flirted with Geb after Luke’s sessions at 2GX, and I’m also keen to explore more native Web-centric tools (like FuncUnit) to explore what kinds of tools are productive for me.  I went live with my first major piece of Grails Commercial Software late last year, but my biggest snags have been browser-specific issues! I’m hoping some functional testing will help.
• JBoss. Ok this one is definitely a little left of centre. But I live in a (mostly) Websphere town and I’m really tired of dealing with the insanity and wastefulness of that platform. I’d really love to have a full-stack alternative (SOA is big in Canberra) that I could offer clients as a migration strategy. I think JBoss is worth exploring here for that reason alone.
• MongoDB. Of all the NoSQL options, Mongo looks the most interesting to me. I own a couple of books, and the Grails support for NoSQL is pretty rocking right now. I think the trickiest part here is actually getting a feel for NoSQL Schema design in document stores. It’s not like there’s an easy “Third Normal Form” type refactoring to apply.

• Training Skills. A lot of the ideas in Pragmatic Thinking and Learning apply specifically to how to train and mentor people. I really want to experiment with this over the course of the year by running some experimental training sessions and see how people cope with alternate presentation/learning courseware. Should have a good impact on the book too!
• Leadership. I’m now serving on the leadership board of several for-profit and non-for-profit organisations. I bring plenty of technical horsepower, but don’t really contribute much in vision casting, strategic planning and people development. All my non-tech reading this year is going to be along the lines of “developing people” but in a Glen-kinda-way rather than just a John-Maxwell-regurgitate kinda way. Honestly there is so much junk written about leadership that is passed on unprocessed…But that’s for another <rant/>
• Minimalism. I’ve actually been applying a bunch of the ideas from “The Joy of Less” that I’ve found really helpful in building a much more conducive living and working space. Think of it as “Eliminate Waste” but applied to your whole life rather than just your code! Lots to learn here, and lots of habits to unlearn to.

Well that should keep me busy for a while…. At least for 2012…

First let’s review last year’s list:

• JavaScript – Yup! I can certainly tick this one off. Did several pieces of hardcore JavaScript work for clients (some without framework support), learned enough QUnit to be dangerous, and even did a bit of Backbone.js.
• Android/HTML5/CSS3 – Check. I’m bundling these together since I ended up doing a major PhoneGap project for a client this year. Had a chance to building a HTML5/CSS3 app for them on iPhone/iPad/Android/Blackberry/WinPhone7. If nothing else, I’m now pretty solid on CSS3 media queries and device toolkits!
• Grails Testing – Check (but lots more work to do). Spent a lot more time writing Spock tests this year and I’m definitely further along the road towards productivity here. Actually, the most useful TDD resource I came across this year was the PragProg screencasts of Kent Beck doing TDD. So practical and non-preachy. Really great. Went ahead and read the original TDD book and found that helpful too!
• Graphic Design. Well. I’ve discovered that I’m fighting city hall on this one. I’ve put too much energy into this for very little result. What I did discover this year was that I can happily customise templates to my cause (Twitter Bootstrap, anyone?) and it’s more productive to outsource the rest!

Also had  chance to do several Grails talks this year including a Grails Code Camp in New Zealand, SpringOne2GX in Chicago, and GR8Conf/OSDC in Canberra.

So what’s on the agenda for 2012? That’s the topic for the next post…

Interesting this is definitely one of the hardest core developer communities I have hung out with. Hardly any Macbooks/iPhones in sight and Linux laptops and Android phones everywhere! People are really committed to the Open Source way here.

The First Ever GR8 Conf in .au

It was great to hang out with a bunch of the awesome team from the local Groovy and Grails community. I gave a shortened version of my SpringOne talk on Grails UI refactors. The slides are up on SlideShare if you missed it:

After a fantastic day of talks from a bunch of great speakers, we had a  chance to kick back with Paul King, Steve Dalton, Craig Aspinall, Peter McNeil, Dean Macaulay, Paul Kilpatrick, James Swann and a bunch of CJUGers at the local watering hole.

Hacking PhoneGap for Fun and Profit

Earlier today I had great fun presenting to an enthusiastic crowd of mobile developers on the joy of PhoneGap. Again, the slides are on SlideShare.

One of the great facilities they had at the conference centre was an old-school data projector. We put it to good use showing off the deployment of our little conference app to my actual Android phone. Ever though a few of the demos snagged, it was all part of the fun of deploying to real devices!

Thanks to @spidie, @jamedmonson, and @davecode for the pics!

Had a fantastic time hanging out with everyone too! Great conference so far!

First things First: Relationships trump everything

The absolute best part of these events is the chance to hang out with our awesome Groovy community making new friends and catching up with old ones. Just have a scan of the Wed night Groovy and Grails BOF (click picture for a closeup) to get a feel for how fantastic our community is (somewhere in this picture are heaps of the names you’ve run across Scott Davis, Graeme Rocher, Burt Beckwith, Guillaume Laforge, Dierk Koenig, Paul King, Colin Harringon, Bobby Warner, Dave Klein, Jim Shingler and many more). The audio will be up on grailspodcast.com shortly.

Friends Old and New

There’s nothing better than catching up with old friends from the Grails community: Andres, Dierk, Scott, Graeme, Jeff, James, Paul, Peter, Luke, Dave & Ken. And it was doubly wonderful to make a whole bunch new friends: Colin Harrington (Grails Testing Guru), Tim Berglund (of the Tim & Matt Git Video fame), Peter Niederwieser (Spock author), Andy Clement (STS Grails IDE support and Agent Reloading) and Jim Shingler (thanks for the insights on Grails in the large!).

And then there is seeing all the great guys from the community including Bob Rullo, Bryan, Jeff Gortatowsky, and too many others to name. So great to see you all!

Grails In Action, 2nd Edition

You asked for, and it’s happening! The most common question heard at the Manning SpringOne2GX desk this week was “Grails in Action, second edition. When?” Thanks so much for your interest (signed heaps of books over the week too!). If you’d like one on the cheap, head over to the Grails in Action page, and use code spring3911 for a 39% discount!

The good news is that Peter Ledbrook and I sat down the Mike Stephens from Manning and thrashed out a plan to get this bad boy up and running. Stay tuned for some MEAP annoucements early 2011. Peter has already started talking about NoSQL coverage, testing deepdive, resources and dependency resolution coverage and tons of other refreshed Grails 2.0 content. I feel tired already! Can’t wait to get started! (Drop us a line if you have specific things you want covered – now is the time to get your requests in!)

Core Inspirations: where to from here?

In case you were interested in the topics covered from the sessions I went to, here are the things on my todo list after 2GX:

• Geb and Functional Specs (Luke session got me thinking here)
• Next Level Spock (Peter Niederwieser is such a champion – and sounds *exactly* like Arnie)
• Taking the Grails Testing movement forward (Colin Harrington really charged me up for this)
• NoSQL perspectives (Graeme’s session on Grails NoSQL was awesome! Super excited about this)
• Coffeescript & Node (not sold on this one, but Scott has persuaded me to at least have a look at Node)

Glen’s Sessions

The 90 minute session format makes it really hard to maintain audience interest, but fortunately I had fantastic people in my session! I ran two sessions, one on refactoring the Grails view tier titled “Does my DIV look big in this?” (lots of Charlie Sheen references lead to a spate of #winning and #tigerblood tweets – it was such a fun crowd we had a ball).

For my second session, I put together a talk titled “Grails Hacker Triage: 10 Grails code smells and refactors” (crowd shown below). This talk was a little experimental and I had quite a few snags pulling it off, but again the crowd were really understanding and had great ideas for improvement next time. Thanks team! I’m going to turn this talk into 10 blog posts over the next month, so stay tuned to dump some “better practices” ideas on me.

So In Summary

This was one of best Grails events I’ve ever been to (so glad I skipped J1 this year to make it!). If you have a chance to get there next year, make sure you do. Great people and Groovy/Grails content made for some fantastic discussions and hangouts. Recommended!

• Grails Resources (for shrinking your dependencies)
• Various Grails and non-Grails DRY view technologies (including bean-fields, navigation, validation and other jQuery related goodness)
• Less.css for keeping your CSS nice and DRY
• Twitter Bootstrap (for gridding and standardised layouts)
• Backbone.js for giving some rigor to my JavaScript views (and painless REST sync)

If any of those technologies are on your radar, make sure you come along! I’m really keen to hear your views on what has worked for you and how we can move towards more low friction Grails views.

We’ll be taking a noisy and loveless default UI:

And giving it a solid makeover for markup, layout and behaviour:

It’s gonna be a blast! See you in Chicago!

Caused by GrailsTagException: Error executing tag <bean:form>: Cannot get property 'class' on null object

You know you’ve tripped the issue.

I’ve logged the issue in GPBEANFIELDS-40 but the root cause is actually not beanfields at all. It’s a breaking change introduced in Grails 2.0.0-M2 for performance improvements (GRAILS-8001). The change has since been made backward compatible for RC1, so the break only occurs on 2.0.0-M2.

Line 922 of BeanFieldsTagLib needs a mod… Comment it out and replace with the mod below

//attrs._BEAN.bean = attrs.remove('bean') ?: pageScope.variables[attrs._BEAN.beanName]
attrs._BEAN.bean = attrs.remove('bean') ?: pageScope.getVariable(attrs._BEAN.beanName)

And you’re in business!

Remember, this ONLY applies to 2.0.0-M2, all will be well in RC1!

Enjoy those DRY forms… And go buy Marc Palmer a nice wine next time you’re in the UK. I plan on it.

Either way you find yourself with a steaming pile of Grails application, and you dread updating the thing because of the carefully crafted house of cards that it’s become.

I know *you* wouldn’t do that. But I would. In a heartbeat. But I’m repenting. And changing. I hope.

I’m starting a blog series cataloguing the biggest and shamless Grails hacks that have slowed me down, and I’d like you to join in the conversation. The end result is going to be a talk at SpringOne 2GX in October called Grails Hacker Triage, where we’ll talk about some strategies for treating these shameless hacks.

So, over the next few weeks, I’m hoping to write about my personal “Top 5 Hacks of Shame”:

1. The Fat Controller: who needs any other artefact when you have this Golden Hammer! Use implicit transactions, generate markup, do querying. What can’t it do when you get creative?
2. The Skinny Model:  You wouldn’t want to clutter up your domain classes with domain logic right?
3. The Nosey Magic Service:  it turns an untyped params object into all kinds of business magic, and has Dr Phil-style  co-dependency problems.
4. The TagLib that ate Tokyo:  it lives and breathes embedded html with a rich tapestry of business logic for good measure. And does a little querying to stay holistic.
5. The 100KLOC view:  With so many logic taglibs built into Grails, why not use them all? And let’s get polyglot by embedding a bunch of JavaScript and CSS FTW.

I suspect I have good examples of all of these pattern in my personal Grails app archive, so I’m off to do some painful researching and personal contemplation.

Look forward to your input on some great personal hacks and remediations along the way!

On the first day I had a chance to speak with around 100 managers on the benefits of Grails (it was quite a challenge putting together a Grails talk targetted to a non-technical audience!). We covered off three big ideas:

1. What is Grails?
2. Why do people choose Grails? (and who has already moved there)
3. How do I transition my team to Grails? (in their case, from Oracle PL/SQL)

Then I couldn’t resist doing a small Grails demo where we built a conference registration app with evolving requirements, then skinned it with the APSUG logo and colours. Even though the crowd was largely non-technical, they were right into the live coding demo! That was a real eye opener. I think people really enjoy things being created before their eyes (whether that’s live painting or live coding!).

The other thing they *really* resonated with was the whole concept of Yak Shaving. For a lot of them, they relate the whole idea of convention-over-configuration to a reduction in Yak Shaving – something which had a clear mental model for them!

The second day we ran a code camp for around 10 of the university developers from the conference. SunGard had put together some great training materials to work through, which I couldn’t resist tweaking a little for the local crowd!

One of the coolest parts of the day was when Bob Rullo from SunGardHE in the States skyped in and took the students through the actual SunGardHE source code for the commercial Grails app they’ll be customising for their own universities. The students were so jazzed to see the same type of Grails Domain Classes and Services that they’d be tinkering with during the camp.

Big thank you to all the folk who brought me over (particularly Victoria University of Wellington), and the great students in the code camp who had to do a little Yak Shaving around the “perfect storm” of Grails 1.3.7, Java 7 and Gemfire! We even prototyped a “grails yak-shave” command to keep us focussed!

Oh. And if you even get to Wellington, make sure you head over to Wellington Zoo to catch the Kiwi Hut and the extremely cute brown kiwis. Those Kiwis are a really awesome and distinctive native animal!

Oh. And I also had a great time catching up with NZ Grails champs @pragmaticgeek @wakaleo @nigel_charman. Looks like we might get a few of the NZ boys over for the GR8 conf that looks like happening in Canberra on Nov 14. Can’t wait!

The error I end up with is typically something like:

java.lang.LinkageError: loader constraint violation: loader (instance of <bootloader>) previously initiated loading for a different type with name “org/xml/sax/SAXParseException”

If you get this on a project after installing a new Grails plugin, this is probably some xml-api clash that the plugin has introduced. The workaround is nicely documented here. Just a matter of excluding xml-api in your BuildConfig and you’re away.

But what if you get this error when running a “grails create-app”? It’s too early to exclude anything – you haven’t even created the project!

To save you reinstalling your JDK/Grails/Groovy distros, it’s time to just blow away your IVY cache – (%USERPROFILE%/.ivy2/cache on Windows) and move on with your life! There’s a nice discussion on the Grails list about tracking down the offending jars using the JAVA_OPS=-verbose option and seeing exactly what is loading those XML classes!

Just wanted to write this down so I can find it later.