General Informations

• For the installation, when you run any ruby programs you better do it with jruby -S <program> to avoid conflicts between ruby and jruby
• if you download a redmine release, rails and gems are already included in the vendor’s folder so you don’t need to install them
• If you have already installed redmine on jruby with some other help and you are having problems (like missing gems or some weird mysql exception), look below the database.yml file and the warble.rb changes, that might fix your problems!

I used the following versions of the different components :

1. redmine 1.0.1
2. jruby 1.5.2
3. mysql 5.0.77
4. glassfish 3.0.1 (build 22)
5. mysql-connector-java-5.1.12

But hopefully any other combination should work as well…

Prerequisites

• download and untar  all the above software if it’s not done yet, install mysql & glassfish.
• add jruby to your PATH variable
• make sure you have access to  mysql with an admin account (root) to create new databases, mysqld (daemon) needs to be running.
• make sure your glassfish installation is working (you can try to login as admin on http://<host>:4848)
• Also in glassfish, configure the Ruby container to point to your jruby installation path

Installation steps

Download gems

Download and install the gems that redmine needs (warble is used to pack redmine rails application as a war file to be deployed on a JEE container, see below):

jruby -S gem install jruby-openssl activerecord-jdbcmysql-adapter warbler

Database setup

• Log on as root and create the redmine database

create database redmine character set utf8;

• create the redmine user account ( change pwd to your own password)

create user 'redmine'@'localhost' identified by 'pwd';

• grant privileges

grant all privileges on redmine.* to 'redmine'@'localhost';

mysql-connector configuration

• copy the mysql-connector.jar file to your glassfish installation lib folder
• in the glassfish bin folder use the asadmin tool to create a connection jdbc pool:

asadmin create-jdbc-connection-pool --datasourceclassname com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource \
--restype javax.sql.DataSource --property "User=redmine:Password=pwd:URL=jdbc\:mysql\://localhost\:3306/redmine" \
jdbc/RedminePool

and

asadmin create-jdbc-resource --connectionpoolid jdbc/RedminePool jdbc/Redmine

Those steps can also be done in the web administration console of glassfish.

redmine configuration

• in the redmine config/environments folder copy production.rb to production_setup.rb
• in the redmine config/ folder copy database.yml.example to database.yml
• modify the config/database.yml file and make sure you have the following with your password:

# MySQL (default setup).

production:
adapter: jdbc
jndi: jdbc/Redmine
driver: com.mysql.jdbc.Driver

production_setup:
adapter: jdbcmysql
database: redmine
host: localhost
username: redmine
password: pwd
encoding: utf8

Create schema and populate default data

In the redmine folder , start the following commands to create the database schema and enter the default data (roles, …) :

jruby -S rake db:migrate RAILS_ENV=production

and

jruby -S rake redmine:load_default_data RAILS_ENV=production

Prepare for deployment

Now we need to prepare the war file that will be deployed to the JEE container. For this step, we use warble.

• first, we need a warble config file. So, in the redmine folder, issue the command

jruby -S warble config

(that generates config/warble.rb file)

• Open config/warble.rb in your preferred editor and modify the line config.dirs so that it contains :

config.dirs = %w(app config lib log vendor tmp extra files lang)

• in the same file add the line

  config.gems["rack"] = "1.0.1"

  and make sure the line

  config.gems += ["activerecord-jdbcmysql-adapter", "jruby-openssl"]

  is not commented out.

• issue the command

   jruby -S warble.

• That should create a war file that you can deploy to your glassfish server.
• An easy way to deploy it to glassfish:

   cp <redmine.war> <glassfishinstallation>/domains/<domainname>/autodeploy/

• and then stop/restart glassfish:

 <glassfishinstallation/bin/asadmin stop-domain <domainname>
<glassfishinstallation/bin/asadmin start-domain <domainname>

Now, redmine should be working!

Start enjoying redmine

Log on to redmin as administrator with admin/admin.

Useful links

redmine installation

redmine on jruby

jdbc connection poll, jndi, rails

In the installation folder of tomcat, go to the subfolder /bin and add somewhere at the beginning of the startup script catalina.sh the line
JAVA_OPTS='-Xms8192M -Xmx8192' for respectively 8GB of memory in this case.

The many-to-many relationship and how Grails treats it is kind of interesting.

Let’s take an example. In a project, I have two domain classes that are connected with a many-to-many relationship, ExpDesign, ExpConditionValue. ExpDesign represents an experimental design, ExpConditionValue represents a value for a condition in a design. So an experimental design (ExpDesign) can have multiple condition values (ExpConditionValue) and those can belong to many ExpDesign. So, that is clearly a many-to-many relationship which needs a join table and Grails knows it.
This is how we tell Grails (with hasMany) about the many-to-many relationship:

class ExpDesign {
    static hasMany = [expConditionValues: ExpConditionValue]
    ...
}
class ExpConditionValue {
    static hasMany = [expDesigns: ExpDesign]
    ...
}

But actually, that’s not enough. We also need to tell Grails (with belongsTo) which class is the owner of the other (more about belongsTo later) :

class ExpConditionValue {
    static hasMany = [expDesigns: ExpDesign]
    static belongsTo = [ExpConditionType]
}

It’s clear that ExpDesign owns ExpConditionValue, therefore I put the belongsTo in ExpConditionValue.

Before I run the code, I want to modify it to specify the names of the mapping tables for my two classes. My convention is to add underscores before upper case letters and pluralize the domain name to define the table name. So here, the tables would be called EXP_DESIGNS and EXP_CONDITION_VALUES. To define the join table name, Grails appends both names with an underscore, so here it would be EXP_DESIGNS_EXP_CONDITION_VALUES. However, as I use Oracle, it will not work because of the length of the table name. I figured this out running describe all_tab_columns (did you know that Oracle limits table name length to 30 characters?). So, I want to specify not only the tables names but also the join table name.

The modified code:

class ExpDesign {
    static mapping = {
        table 'EXP_DESIGNS'
        expConditionValues joinTable: 'EXP_COND_VALS_DESIGNS'
    }

    static hasMany = [expConditionValues: ExpConditionValue]
    ...
}
class ExpConditionValue {
    static mapping = {
        table ' EXP_COND_VALUES'
        expDesigns joinTable: 'EXP_COND_VALS_DESIGNS'
    }
    static hasMany = [expDesigns: ExpDesign]
    static belongsTo = [ExpDesign]
    ...
}

With that I let Grails take care about the relationship, I just enforced the names of the domain tables and the join table.

belongsTo

belongsTo tells grails that the other class is the owning class in the relationship. In my case, ExpDesign owns (many) ExpConditionValue. The first consequence is that ExpDesign deletes will be cascaded to ExpConditionValues. Whenever a ExpDesign will be deleted all its associated ExpConditionValues will be deleted as well, without the belongsTo they would not.
In the case above, I have used the unidirectional belongsTo clause but a bidirectional version exists as well (e.g. static belongsTo = [expD : ExpDesign]) which would enable to navigate from the object to its owning object.

What is interesting as well is that belongsTo combined to hasMany tell Grails enough about our model that it will be able to add up some dynamic methods like exp.addToExpConditionValues(val1) that will automatically persist objects to the DB.

Thanks to grails, a lot of the magic happens in the background and for us much less tedious code to write!

But that’s not always enough. In the current system I’m working on I decided to add a boolean flag deleted on some domain objects. The reason is that I cannot allow normal users to really delete the objects from the db, so when a user deletes an object I just flag the object as being deleted, thus I can always recover it. However, I don’t want this object to appear anymore in the list. So, an easy way to achieve that is withCriteria. If you wonder what the difference is between withCriteria and createCriteria, from what I understood withCriteria is just a shorter form of createCriteria.

First, the default list method in the controller is generated by the scaffolding:

def list = {
  params.max = Math.min( params.max ? params.max.toInteger() : 10,  100)
  [ dataTypeInstanceList: DataType.list( params ), dataTypeInstanceTotal: DataType.count() ]
}

And that the method I first added to my domain object DataType using createCriteria:

static notDeleted(params) {
  createCriteria().list(max: params.max, offset: params.offset, sort: params.sort, order: params.order) {
     and {
              eq('deleted', false)
           }
   }
}

There should be a shorter version with withCriteria which should work as good as the previous one from what I have read. I tried something like the following but the pagination didn’t work.:

static notDeleted(params) {
    withCriteria {
        eq('deleted', false)
    }
}

It looks pretty simple but it’s pretty powerful as you can combine a lot of operator.

And below my modified list method in the controller with a modified count:

def list = {
  params.max = Math.min( params.max ? params.max.toInteger() : 10,  100)
  [ valueInstanceList: Value.notDeleted( params ), valueInstanceTotal: Value.countByDeleted(false) ]
}

def sql = groovy.sql.Sql.newInstance("jdbc:oracle:thin:@server.domain:1521:database", "user", "password", "driver")

sql.eachRow("select * from database.table where table_column_ = 'xxxx") {
newDescription = (it.description =~ /Rat/).replaceAll('Mouse')
id = it.id
updateCall = "update database.table set description = '$newDescription' where id = $id"
sql.executeUpdate(updateCall)
}

• Line 1 creates a sql connection to the database
• Line 3 iterates through the results of the passed select statement (each row will be in the it and fields can be accessed by their name)
• Line 4 does the regular expression find&replace in the description string
  • =~ looks if there is a match (takes it.description as argument)
  • The slash defines the RegEx. So in our case we are looking for Rat (/Rat/, for first letter lower and upper case we could have put /[R|r]at/)
  • and finally .replaceAll(‘Mouse’) to replace what was found with the regular expression
• Line 6 & 7 to build and call the update

Scripting languages like groovy can sometimes be very painful but luckily more often they are just great!

package com.arak.sensor.accele;

import android.view.View;
import android.hardware.SensorManager;
import android.hardware.SensorListener;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.graphics.Paint;
import android.graphics.Color;

import java.util.LinkedList;
import java.text.DecimalFormat;

public class AcceleView extends View implements SensorListener {

    public final static int MAX_VALUES = 200;
    public final static int SCALING = 3; // for G to graphic
    public final static int GSCALING = 2; // for panels
    public final static int MARGIN_TOP = 15;
    public final static int SEPARATION = 20;
    public final static int MARGIN_LEFT = 10;

    private long timekeeper;

    private final LinkedList<float[]> fifo;
    private float height;
    private float width;
    private float halfRectHeight;

    private float xYLine;
    private float yYLine;
    private float zYLine;
    private float pX;
    private float pY;
    private float pZ;
    private float minX;
    private float minY;
    private float minZ;
    private float maxX;
    private float maxY;
    private float maxZ;

    public AcceleView(Context context, SensorManager sma) {
        super(context);
        timekeeper = android.os.SystemClock.uptimeMillis();
        fifo = new LinkedList<float[]>();
        int mask = 0;
        mask |= SensorManager.SENSOR_ORIENTATION;
        mask |= SensorManager.SENSOR_ACCELEROMETER;
        sma.registerListener(this, mask, SensorManager.SENSOR_DELAY_FASTEST);
        pX = 0f;
        pY = 0f;
        pZ = 0f;
        minX = 0f;
        minY = 0f;
        minZ = 0f;
        maxX = 0f;
        maxY = 0f;
        maxZ = 0f;
    }

    protected void onDraw(Canvas canvas) {
        height = canvas.getHeight();
        width = canvas.getWidth();
        halfRectHeight = SCALING * 10 *GSCALING;
        xYLine = MARGIN_TOP + SCALING * 10 *GSCALING;
        yYLine = xYLine + halfRectHeight * 2 + SEPARATION;
        zYLine = yYLine + halfRectHeight * 2 + SEPARATION;

        clear(canvas);
        drawGridAndLastValues(canvas);
        drawValues(canvas);
    }

    public void onSensorChanged(int sensor, float[] values) {
        if (android.os.SystemClock.uptimeMillis() < timekeeper + 20) return;
        timekeeper = android.os.SystemClock.uptimeMillis();
        final float[] val = new float[]{values[0], values[1], values[2]}; // defensive copy because keeps the same object

        if (sensor == SensorManager.SENSOR_ACCELEROMETER) {
            if (fifo.size() > MAX_VALUES) fifo.poll();
            fifo.add(val);
            minX = Math.min(minX, val[0]);
            minY = Math.min(minY, val[1]);
            minZ = Math.min(minZ, val[2]);
            maxX = Math.max(maxX, val[0]);
            maxY = Math.max(maxY, val[1]);
            maxZ = Math.max(maxZ, val[2]);
            invalidate();
        }

    }

    public void onAccuracyChanged(int i, int i1) {
        /* @todo implement method */
    }

    private void clear(Canvas canvas) {
        Rect rect = new Rect();
        rect.set(0, 0, canvas.getWidth(), canvas.getHeight());
        Paint p = new Paint();
        p.setStyle(Paint.Style.FILL);
        p.setColor(Color.WHITE);
        canvas.drawRect(rect, p);
    }

    private void drawGridAndLastValues(Canvas canvas) {
        Paint p = new Paint();

        // print measured values
        DecimalFormat df = new DecimalFormat("##.#");
        String xStringVal = df.format(pX);
        String yStringVal = df.format(pY);
        String zStringVal = df.format(pZ);
        String xMinStringVal = df.format(minX);
        String yMinStringVal = df.format(minY);
        String zMinStringVal = df.format(minZ);
        String xMaxStringVal = df.format(maxX);
        String yMaxStringVal = df.format(maxY);
        String zMaxStringVal = df.format(maxZ);

        //x
        String xText = "X values [last: " + xStringVal + " - min:" + xMinStringVal + " - max:" + xMaxStringVal + "]";
        p.setColor(Color.LTGRAY);
        canvas.drawRect(MARGIN_LEFT, xYLine - halfRectHeight, width - MARGIN_LEFT, xYLine + halfRectHeight, p);
        p.setColor(Color.BLACK);
        canvas.drawLine(MARGIN_LEFT, xYLine, width - MARGIN_LEFT, xYLine, p);
        canvas.drawText(xText, MARGIN_LEFT + width / 6, xYLine - halfRectHeight - 2, p);
        canvas.drawText("+2G", MARGIN_LEFT, xYLine - halfRectHeight + 10, p);
        canvas.drawText("-2G", MARGIN_LEFT, xYLine + halfRectHeight, p);

        //y
        String yText = "Y values [last: " + yStringVal + " - min:" + yMinStringVal + " - max:" + yMaxStringVal + "]";
        p.setColor(Color.LTGRAY);
        canvas.drawRect(MARGIN_LEFT, yYLine - halfRectHeight, width - MARGIN_LEFT, yYLine + halfRectHeight, p);
        p.setColor(Color.BLACK);
        canvas.drawLine(MARGIN_LEFT, yYLine, width - MARGIN_LEFT, yYLine, p);
        canvas.drawText(yText, MARGIN_LEFT + width / 6, yYLine - halfRectHeight - 2, p);
        canvas.drawText("+2G", MARGIN_LEFT, yYLine - halfRectHeight + 10, p);
        canvas.drawText("-2G", MARGIN_LEFT, yYLine + halfRectHeight, p);

        //z
        String zText = "Z values [last:" + zStringVal + " - min:" + zMinStringVal + " - max:" + zMaxStringVal + "]";
        p.setColor(Color.LTGRAY);
        canvas.drawRect(MARGIN_LEFT, zYLine - halfRectHeight, width - MARGIN_LEFT, zYLine + halfRectHeight, p);
        p.setColor(Color.BLACK);
        canvas.drawLine(MARGIN_LEFT, zYLine, width - MARGIN_LEFT, zYLine, p);
        canvas.drawText(zText, MARGIN_LEFT + width / 6, zYLine - halfRectHeight - 2, p);
        canvas.drawText("+2G", MARGIN_LEFT, zYLine - halfRectHeight + 10, p);
        canvas.drawText("-2G", MARGIN_LEFT, zYLine + halfRectHeight, p);

    }

    private void drawValues(Canvas canvas) {
        float len = (width - MARGIN_LEFT * 2) / MAX_VALUES;
        Paint p = new Paint();

        float xVal = MARGIN_LEFT;

        boolean first = true;

        for (float[] f : fifo) {
            float x = f[0];
            float y = f[1];
            float z = f[2];
            if (first) {
                pX = x;
                pY = y;
                pZ = z;
                first = false;
            }
            p.setColor(Color.GREEN);
            canvas.drawLine(xVal, xYLine - pX * SCALING, xVal + len, xYLine - x * SCALING, p);
            p.setColor(Color.RED);
            canvas.drawLine(xVal, yYLine - pY * SCALING, xVal + len, yYLine - y * SCALING, p);
            p.setColor(Color.BLUE);
            canvas.drawLine(xVal, zYLine - pZ * SCALING, xVal + len, zYLine - z * SCALING, p);
            xVal += len;
            pX = x;
            pY = y;
            pZ = z;
        }
    }
}// END

package com.arak.sensor.accele;

import android.app.Activity;
import android.os.Bundle;
import android.hardware.SensorManager;
import android.content.Context;

public class ShowSensor extends Activity {

    private AcceleView av;

    @Override
    public void onCreate(Bundle args) {
        super.onCreate(args);
        av = new AcceleView(this, (SensorManager) getSystemService(Context.SENSOR_SERVICE));
        setTitle("Show Sensor Values");
        setContentView(av);
    }
}

{
list = new ArrayList()
}

Assuming the list member has been defined, this code will be executed just as it would have been inserted at the very beginning of the constructor.
And if there would be many of them, they would all be called in the order they appear in the class (ok, that’s even more dangerous !). Initialization blocks can also throw exceptions, as long as the constructor throws the same exceptions as well.
Now the question is: why would you use an initialization block instead of putting everything in the constructor or in a init() method like we always do. I guess, it depends. For sure, init() cannot set final members, initialization blocks can.
Also, in an anonymous inner classes, we cannot define constructors, a initialization block can play the constructor role. Code generators can also take advantage of initialization blocks, UI builders for instance.
Here is a little examples of a class with two initialization blocks and random exception.

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class TryItOut {

    private List list;

    {
        System.out.println("calling Hello()");
        hello();
    }

    {
        System.out.println("adding element to list");
        list.add("blabla");
        if (new Random().nextBoolean())throw new Exception("exception!");
    }

    public TryItOut() throws Exception {
        System.out.println("starting constructor, how many elements? ");
        System.out.println(list.size());
    }

    public void hello() {
        System.out.print("hello");
        list = new ArrayList();
        for (int i = 0; i < 10; i++) list.add("hello" + i);
        System.out.println(" world " + list.size());
    }

    public final static void main(String[] args) {
        try {
            new TryItOut();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

Interesting, isn't it?? ]]> http://karanar.net/?feed=rss2&p=118 0 http://karanar.net/?p=93 http://karanar.net/?p=93#comments Fri, 29 Jan 2010 18:26:33 +0000 karanar http://karanar.net/?p=93 I’m currently working on refactoring an UI/ORM application and the database it connects to. I need to change a lot of things in the db design so I was looking for a simple java tool that would allow me to easily export tables from the database to a defined XML format. A tool that would produce something . . . → Read More: Exporting a database to XML with Groovy]]> I’m currently working on refactoring an UI/ORM application and the database it connects to. I need to change a lot of things in the db design so I was looking for a simple java tool that would allow me to easily export tables from the database to a defined XML format.
A tool that would produce something like that:

value_col1
value_val2


value_col1
value_val2

I briefly googled but I couldn’t find anything free and easy to use. I know there must be! Anyway, I found an elegant way to do it with Groovy and wanted to share it.

def sql = groovy.sql.Sql.newInstance("connectionString", "user", "password", "db_driver")

def fileOut = new FileWriter("/path/to/out/put/file.xml")

def xml = new groovy.xml.MarkupBuilder(fileOut)
xml.table_entries {
  sql.eachRow("select * from schema.table") {row ->
    entry {
      column1(row.column1)
      column2(row.column2)
      ...
    }
  }
}

1 minute to write the code to export one table, isn’t Groovy great?