How to do logging in Groovy

For some reason I couldn’t find any information about how to do logging in the two Groovy books that are available at work. I have been using Groovy for a few days now and I’m surprised about all the little tweaks and improvements the developers made to reduce code duplication and boilerplate code. For this reason, I figured that there must be a rather straightforward way to do logging in Groovy. And of course, there is one!

Please note that the following was introduced with Groovy version 1.8 and therefore won’t work in earlier versions. I don’t know about any best practices for earlier Groovy versions, but I fear that you may need to do it the way that you are used to, i.e., the Java way.

I’m going to show this using SLF4J as I always try to decouple my program from specific logging frameworks. First of, let’s start with our build.gradle file (gradle project descriptor). Continue reading

How-to install KeePassX on Ubuntu

Do you have to remember an ever increasing amount of passwords? If you do, then KeePassX might be of interest to you. It’s a password manager which has high security standards and which is additionally available on Microsoft Windows and Mac OS X. If you are running Ubuntu (this probably also applies to recent Debian versions), the following snippet might be of interest to you as it shows how to install version 0.4.3 of this program. After installation, you can find it in your desktop manager’s application menu (under GNOME 2 it’s located in Applications -> Accessories -> KeePassX).

NAME='keepassx-0.4.3'
FILENAME=$NAME'.tar.gz'

echo ':: Installing prerequisites...'
sudo apt-get install libxtst-dev libqt4-dev qt4-qmake

echo ':: Downloading and extracting file...'
wget 'http://downloads.sourceforge.net/keepassx/'$FILENAME
tar xvf $FILENAME

echo ':: Installing...'
cd $NAME
qmake
make
sudo make install

echo ':: Cleaning up...'
cd ..
rm -rf $NAME $FILENAME

How-to install nginx

Since there is so much buzz around nginx, I wanted to give it a try on my small home server. The server is running a desktop edition of Ubuntu 10.04 (I keep it as backup machine in case my laptop breaks), so keep this in mind. The following bash script will download nginx version 1.1.12, its dependencies and install it. Also, a user nginx will be created.

# Start by creating an appropriate user
useradd -r nginx
mkdir /home/nginx
chown nginx:nginx /home/nginx/

# Retrieve nginx dependencies
cd /home/nginx
mkdir library
cd library
wget http://zlib.net/zlib-1.2.5.tar.gz
tar xfz zlib-1.2.5.tar.gz
rm zlib-1.2.5.tar.gz
wget ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-8.21.tar.gz
tar xfz pcre-8.21.tar.gz
rm pcre-8.21.tar.gz
cd ..

# Installing nginx
wget http://nginx.org/download/nginx-1.1.12.tar.gz
tar xfz nginx-1.1.12.tar.gz
rm nginx-1.1.12.tar.gz
cd nginx-1.1.12
./configure --prefix=/home/nginx \
    --user=nginx \
    --group=nginx \
    --with-pcre=../library/pcre-8.21/ \
    --with-zlib=../library/zlib-1.2.5/
make
make install
cd ..
rm -rf nginx-1.1.12/
chown -R nginx:nginx *
sed -i 's/listen\s*80;/listen 8080;/g' conf/nginx.conf
export NGINX_HOME='/home/nginx/'
export NGINX_PID_FILE=$NGINX_HOME'logs/nginx.pid'

In case you encounter any problems, please refer to the short, but sufficient, official documentation. If it worked out for you, you can now use the following commands to start and stop the server as well as to reload the config.

# Start nginx (runs on port 8080)
su nginx -c $NGINX_HOME'sbin/nginx'

# Reload nginx config
kill -HUP $(cat $NGINX_PID_FILE)

# Stop nginx
kill -QUIT $(cat $NGINX_PID_FILE)

Check out the following blog if you need an init script for nginx.

Define JNDI data source for Apache Tomcat

Defining data sources via JNDI has various benefits, e.g. pooling and completely external configuration. The latter is especially important as this avoids putting database credentials into your application. Since I’m currently studying the Spring framework, I also wanted to use another application server. In fact, I wanted to try Apache Tomcat 7, a servlet container.

I have to say that I found the JNDI how-to for Apache Tomcat insufficient and therefore want to share some information that I collected in addition to the how-to.

At first, they show what a context.xml file should look like but they don’t tell you where to put it (ok they lead you to another documentation page). I found the simplest place to be the $CATALINA_BASE/conf/context.xml as this is probably sufficient for most use cases. Please note though that all deployed applications will have access to this data source. The next thing you shouldn’t forget is to put the driver into $CATALINA_BASE/lib/. In combination with the aforementioned how-to this should be all you need to use JNDI data sources with Apache Tomcat.

SVG path arc curve command

The basic SVG rect shape provides functionality for rounded corners. Unfortunately, you can only change it for all four corners. I needed a rectangle which supports something like the CSS3 top- and bottom-border-radius instructions.

#foo {
    border-top-left-radius: 10px;
    border-top-right-radius: 10px;
    border-bottom-right-radius: 20px;
    border-bottom-left-radius: 20px;
}

I needed this because of my GSoC project. In this project, there are different nodes types which have to be visualized. You can see the two node types (which are the reason for this blog post) in the following figure.

Two node types of the SBGN

The two node types which are the reason for this blog post.

Sticking to the Don’t-Repeat-Yourself paradigm, I abstracted the drawing of rectangular shapes into a base class RectangularNode from which the classes Macromolecule and NucleicAcidFeature inherit. Since the two node types are the same (with regard to implementation), except for the border radius, I put all the funtionality into the base class RectangularNode. Now the Macromolecule and NucleicAcidFeature classes are merely subclasses which set the border radius on the RectangularNode class.

Now to the drawing of rectangles with different border-radii, there is no basic SVG shape which supports such behavior. As a result, you need the SVG path element. The path element enables you to draw such things as curves and arcs and can be used to draw every possible shape. For this specific issue, the arc is needed. Please refer to the specification for an explanation of the various commands and the path element in general. In this post I’ll only cover the generation of rectangles with different border radii and the arc command. The arc command is defined the following way (expressed as a regular expression in JavaScript with an example parsing). Continue reading