Deploying GWT-Ext
If you’ve not used GWT-Ext before then here’s how to include it in your GWT application. First you’ll need to download GWT-Ext itself. At the time of writing 2.0.4 is the latest release, you can get it here. The real workhorse behind GWT-Ext is the Javascript library ExtJS. GWT-Ext 2.0.4 requires ExtJS 2.0.2 which you can download from here.

If you don’t already have a GWT application then GWT’s The Basics guide is a good place to start.

With your application up and running here are the steps required to deploy GWT-Ext within it.

1. Create the directory js/ext under your application’s public folder and copy the following files and directories from ExtJS into it,

adapter
resources
ext-all.js
ext-all-debug.js
ext-core.js
ext-core-debug.js

2. Edit your module file and add these lines to it,

<inherits name='com.gwtext.GwtExt'/>
<stylesheet src="js/ext/resources/css/ext-all.css"/>
<script src="js/ext/adapter/ext/ext-base.js" />
<script src="js/ext/ext-all.js" />

3. The final step it to add the GWT-Ext jar, gwtext.jar, to your application’s classpath.

The Client Side Code
GWT-Ext refers to a listview as a Grid so to avoid confusion I’ll use that term throughout the rest of this post. I used the term listview up to this point because it’s probably a more generally accepted description.

Before going into the code it’s worth spending a little time understanding the various objects that are needed to support the Grid object. The first thing worth pointing out is that GWT-Ext doesn’t use standard GWT Remote Procedure Calls to fetch the data needed in the Grid. What you do instead is provide it with a HTTP URL from which to retrieve the data. To do this you use a DataProxy object. There are three types of DataProxy, the HttpProxy, the MemoryProxy and the ScriptTagProxy. The MemoryProxy is just a static in memory data source and the ScriptTagProxy is the same as HttpProxy except that it retrieves data from a site other than the one where your Grid is hosted. So what format should the data coming back from this URL be in? Two formats are supported, JSON and XML. In order to understand the structure of this JSON or XML we need to use a RecordDef. This object contains FieldDef objects each of which describe a particular field in the data feed. Once you’ve described you data structure using a RecordDef you create either a JsonReader or an XmlReader and give it a reference to your RecordDef. Finally, to tie all these objects together you create a Store. The Store is the object you present to the Grid. It uses the DataProxy to retrieve the data and and the Reader to parse it.

With the Store defined we can turn our attention to the Grid. To define what columns the Grid should have and where the data for each column should come from we use a ColumnModel object. This object contains a number of ColumnConfig objects, one for each column. A ColumnConfig contains the column title, the name of the record in the RecordDef to populate the column with, it’s width, weather it’s sortable and how the data should be rendered. To create the Grid itself we use the GridPanel object. You can link it to the Store and ColumnModel using either the constructor or the setter methods.

The final point to note is that you’ll need to add an onRender event handler to the Grid so that the first page of data is loaded when the Grid is displayed.

Bringing all that together here’s the class I ended up with,

package com._17od.gwtexamples.client;

import java.util.Date;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.client.ui.RootPanel;
import com.gwtext.client.core.SortDir;
import com.gwtext.client.data.DateFieldDef;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.HttpProxy;
import com.gwtext.client.data.IntegerFieldDef;
import com.gwtext.client.data.JsonReader;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.util.DateUtil;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.PagingToolbar;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.grid.CellMetadata;
import com.gwtext.client.widgets.grid.ColumnConfig;
import com.gwtext.client.widgets.grid.ColumnModel;
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.GridView;
import com.gwtext.client.widgets.grid.Renderer;
import com.gwtext.client.widgets.grid.RowSelectionModel;

public class PersonGrid implements EntryPoint {

	public void onModuleLoad() {

		Panel panel = new Panel();
		panel.setBorder(false);
		panel.setPaddings(15);

		HttpProxy dataProxy = new HttpProxy("http://localhost:8888/persons");

        final RecordDef recordDef = new RecordDef(new FieldDef[]{
                new StringFieldDef("class"),
                new DateFieldDef("dateOfBirth", "Y-m-d"),
                new StringFieldDef("firstname"),
                new IntegerFieldDef("id"),
                new StringFieldDef("lastname"),
        });

        JsonReader reader = new JsonReader(recordDef);
        reader.setRoot("persons");
        reader.setTotalProperty("totalPerons");
        reader.setId("id");

        final Store store = new Store(dataProxy, reader, true);
        store.setDefaultSort("id", SortDir.ASC);

        ColumnConfig firstNameColumn = new ColumnConfig("First Name", "firstname", 45, true);
        ColumnConfig lastNameColumn = new ColumnConfig("Last Name", "lastname", 45, true);
        ColumnConfig dateOfBirthColumn = new ColumnConfig("Date of Birth", "dateOfBirth", 45, true, dateRender);

        ColumnModel columnModel = new ColumnModel(new ColumnConfig[] {
        		firstNameColumn,
        		lastNameColumn,
        		dateOfBirthColumn});
        columnModel.setDefaultSortable(true);

        GridPanel grid = new GridPanel();
        grid.setWidth(700);
        grid.setHeight(300);
        grid.setTitle("People");
        grid.setStore(store);
        grid.setColumnModel(columnModel);
        grid.setTrackMouseOver(true);
        grid.setLoadMask(true);
        grid.setSelectionModel(new RowSelectionModel());
        grid.setStripeRows(true);
        grid.setIconCls("grid-icon");
        grid.setEnableColumnResize(true);

        GridView view = new GridView();
        view.setForceFit(true);
        grid.setView(view);

        PagingToolbar pagingToolbar = new PagingToolbar(store);
        pagingToolbar.setPageSize(15);
        pagingToolbar.setDisplayInfo(true);

        grid.setBottomToolbar(pagingToolbar);

        grid.addListener(new PanelListenerAdapter() {
            public void onRender(Component component) {
                store.load(0, 15);
            }
        });
        panel.add(grid);

        RootPanel.get().add(panel);

  	}

    private Renderer dateRender = new Renderer() {
        public String render(Object value, CellMetadata cellMetadata, Record record, int rowIndex, int colNum, Store store) {
            return DateUtil.format((Date) value, "d-m-Y");
        }
    };

}

Where Does the Data Come From?
The code below is the servlet I developed to return each page of data to the Grid. It retrieves the data from an Oracle database table called “person”. It’s not particularly complicated but it does demonstrate some challenges that are worth pointing out.

package com._17od.gwtexamples.servlets;

import java.io.IOException;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Enumeration;

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

import oracle.jdbc.pool.OracleDataSource;

import org.json.JSONArray;
import org.json.JSONObject;

public class GetPersonsServlet extends HttpServlet {

	private Connection connection;

	public void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException {
		doPost(req, res);
	}

	public void doPost(HttpServletRequest req, HttpServletResponse res) throws IOException {

		// Display the parameters we're passed in for debugging purposes
		printParameters(req);

		// Get the limit and sort parameters off the request
		int start = req.getParameter("start") == null ? 1 : Integer.parseInt(req.getParameter("start"));
		int numberToReturn = req.getParameter("limit") == null ? 10 : Integer.parseInt(req.getParameter("limit"));
		String sortBy = req.getParameter("sort") == null ? "id" : req.getParameter("sort");
		String sortOrder = req.getParameter("dir") == null ? "asc" : req.getParameter("dir");

		// Create the SQL query used to retrieve the persons
		String sql = createMainSQLQuery(sortBy, sortOrder);

		ArrayList persons = null;
		try {

			// Get a connection to the Oracle database and put it on the object so that it's easily accessible
			connection = getConnection();

			// Execute the query to return the exact records requested
			persons = queryForPersonsUsingLimits(sql, start, numberToReturn);

			// Convert the list of persons into a JSON string
			JSONObject jsonDataToReturn = new JSONObject();
			JSONArray jsonPersons = new JSONArray(persons, true);
			jsonDataToReturn.put("totalPerons", getTotalNumberOfPersons(sql));
			jsonDataToReturn.put("persons", jsonPersons);

			// Write everything back to the requestor
			res.getWriter().print(jsonDataToReturn.toString(1));

		} catch (Exception e) {
			e.printStackTrace();
			throw new IOException(e);
		} finally {
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
					throw new IOException(e);
				}
			}
		}

	}

	/**
	 * Create the query used to retrieve the persons from the database.
	 * @param sortBy
	 * @param sortOrder
	 * @return
	 */
	private String createMainSQLQuery(String sortBy, String sortOrder) {

		StringBuffer sql = new StringBuffer("SELECT id, firstname, lastname, dateofbirth FROM person");
		sql.append(" ORDER BY ");
		sql.append(sortBy);
		sql.append(" ");
		sql.append(sortOrder);

		return sql.toString();

	}

	/**
	 * Wrap the query passed in with some extra SQL that pulls out the exact
	 * page of persons requested, i.e. starting at record number 10 return 20
	 * records.
	 * It's vital that the query given in 'sql' has an 'order by' clause.
	 * If it didn't then the persons could be returned in a random order
	 * making it impossible to order them into pages.
	 * @param sql
	 * @param start
	 * @param numberToReturn
	 * @return
	 * @throws SQLException
	 */
	private ArrayList queryForPersonsUsingLimits(String sql, int start, int numberToReturn) throws SQLException {

		StringBuffer sqlBuffer = new StringBuffer("SELECT * FROM (SELECT a.*, ROWNUM rnum from (");
		sqlBuffer.append(sql);
		sqlBuffer.append(") a WHERE ROWNUM <= ");
		sqlBuffer.append(start + numberToReturn);
		sqlBuffer.append(") WHERE rnum > ");
		sqlBuffer.append(start);

		Statement statement = null;
		ResultSet rs = null;

		ArrayList
 persons = new ArrayList
();

		try {

			statement = connection.createStatement();
			rs = statement.executeQuery(sqlBuffer.toString());

			while (rs.next()) {
				Person person = new Person();
				person.setId(rs.getInt("id"));
				person.setFirstname(rs.getString("firstname"));
				person.setLastname(rs.getString("lastname"));
				person.setDateOfBirth(rs.getDate("dateofbirth"));
				persons.add(person);
			}

		} finally {
			if (rs != null) {
				rs.close();
			}
			if (statement != null) {
				statement.close();
			}
		}

		return persons;

	}

	/**
	 * Return the total numbner of records that the given query will return.
	 * @param sql
	 * @return
	 * @throws SQLException
	 */
	private int getTotalNumberOfPersons(String sql) throws SQLException {

		int count = 0;

		StringBuffer sqlBuffer = new StringBuffer("SELECT COUNT(*) count FROM (");
		sqlBuffer.append(sql);
		sqlBuffer.append(")");

		Statement statement = null;
		ResultSet rs = null;

		try {

			statement = connection.createStatement();
			rs = statement.executeQuery(sqlBuffer.toString());

			while (rs.next()) {
				count = rs.getInt("count");
			}

		} finally {
			if (rs != null) {
				rs.close();
			}
			if (statement != null) {
				statement.close();
			}
		}

		return count;

	}

	/**
	 * Return a database connection from the connection poll that's stored on the servlet/application context
	 * @return
	 * @throws SQLException
	 */
	private Connection getConnection() throws SQLException {
		OracleDataSource ods = (OracleDataSource) getServletContext().getAttribute("CONNECTION_POOL");
		if (ods == null) {
			ods = createConnectionPool();
			getServletContext().setAttribute("CONNECTION_POOL", ods);
		}
		return ods.getConnection();
	}

	/**
	 * Create a database connection pool
	 * @return
	 * @throws SQLException
	 */
	private OracleDataSource createConnectionPool() throws SQLException {
        String username = "replace with db username";
        String password = "replace with db password";
        String url = "jdbc:oracle:thin:@localhost:1521:XE";

        OracleDataSource ods = new OracleDataSource();
        ods.setURL(url);
        ods.setUser(username);
        ods.setPassword(password);
        ods.setConnectionCachingEnabled(true);

        return ods;
	}

	private void printParameters(HttpServletRequest req) {
		Enumeration parameterNames = req.getParameterNames();
		System.out.println("\nRequest Parameters:");
		while (parameterNames.hasMoreElements()) {
			String parameterName = (String) parameterNames.nextElement();
			System.out.println(" " + parameterName + "=" + req.getParameter(parameterName));
		}
	}

}

The first point of interest in doPost() is the code that takes the ordering and limit parameters off the request. This servlet is requested when the grid is first drawn or when the user clicks on the “Next Page” or “Previous Page” buttons. For the paging to work the data needs to be ordered. The sort parameter indicates what column to sort the data by. It uses the name you give the column in the RecordDef when creating the Grid. The dir parameter says what direction the ordering should be in, ascending or descending. The start parameter is the number of the first record to return and limit is the number of records to return.

Now that we know what the user is asking for it’s time to build the SQL query that will fetch that data. The method createMainSQLQuery() creates a query string to select the required columns and order the ResultSet.

In the next section we call getConnection(). This method (and createConnectionPool()) demonstrate how to create an Oracle connection pool using OracleDataSource and it’s method setConnectionCachingEnabled().

The method queryForPersonsUsingLimits() is where we actually execute the query. In the first section the query is wrapped in some SQL that fetches only the rows we want starting at row start and returning only numberToReturn records. I picked this up from this Ask Tom article. It’s well worth a read if you’re interested in how the ROWNUM pseudocolumn works.

The next section takes the query ResultSet, creates a Person object for each row and puts each on an ArrayList.

Back in doPost() the ArrayList of Persons is serialized to JSON text using the JSON classes freely availabe here. The method getTotalNumberOfPersons() is called to retrieve the total number of rows the query would return if we weren’t limiting the results. The reason we need this is because the Grid will have a message at the bottom saying like “Displaying 1 to 20 of 100”. The getTotalNumberOfPersons() method reuses the SQL we created earlier and simply wraps it in a SELECT COUNT(*).

Finally we write the JSON text to the output stream which is sent back to the browser.

Deploying the servlet into a web application is simply a matter of adding servlet and servlet-mapping entries to the application’s web.xml. For testing purposed I chose to use the web application created by GWT. By default this application is located in the <project dir>\tomcat\webapps\ROOT. Here are the entries I added…

<servlet>
    <servlet-name>GetPersonsServlet</servlet-name>
    <servlet-class>com._17od.GetPersonsServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>GetPersonsServlet</servlet-name>
    <url-pattern>/persons</url-pattern>
</servlet-mapping>

Here’s a sample of the JSON returned from the URL http://localhost:8888/persons?start=2&limit=3.

{
 "persons": [
  {
   "class": "class com._17od.servlets.Person",
   "dateOfBirth": "1901-01-17",
   "firstname": "Laurel",
   "id": 3,
   "lastname": "Davis"
  },
  {
   "class": "class com._17od.servlets.Person",
   "dateOfBirth": "1892-05-16",
   "firstname": "Ted",
   "id": 4,
   "lastname": "Schoenberger"
  },
  {
   "class": "class com._17od.servlets.Person",
   "dateOfBirth": "2001-05-19",
   "firstname": "Rebecca",
   "id": 5,
   "lastname": "Taylor"
  }
 ],
 "totalPerons": 20
}

The JSON implementation I’m using includes the name of the class being serialized, hence the class attribute.

Since I’ve included all the other code here’s the Person class,

package com._17od.gwtexamples.servlets;

import java.util.Date;

public class Person {

	private int id;
	private String firstname;
	private String lastname;
	private Date dateOfBirth;

	public Date getDateOfBirth() {
		return dateOfBirth;
	}

	public void setDateOfBirth(Date dateOfBirth) {
		this.dateOfBirth = dateOfBirth;
	}

	public String getFirstname() {
		return firstname;
	}

	public void setFirstname(String firstname) {
		this.firstname = firstname;
	}

	public int getId() {
		return id;
	}

	public void setId(int personId) {
		this.id = personId;
	}

	public String getLastname() {
		return lastname;
	}

	public void setLastname(String lastname) {
		this.lastname = lastname;

	}

}

To finish off here’s a screenshot of the Grid,

TypeError: 'hgwebdir' object is not callable

There may be a number of scenarios under which this error can happen but in my case it was because I was using an incompatible version hgwebdir.cgi. After installing Mercurial 0.9.4 I downloaded hgwebdir.cgi from here (which at the time of writing was for Mercurial 1.0). To fix the problem I had to use the version of hgwebdir.cgi that came with the Mercurial 0.9.4 install. On Ubuntu you’ll find it here /usr/share/doc/mercurial/examples/hgwebdir.cgi.

As it happens, getting Internet Explorer to work in Linux is relatively straightforward. The tricky bit it pulling the various pieces of the puzzle together.

Install Wine and Internet Explorer
Because the problem of not having access to IE within Linux is such a common problem, some nice people have put together an install process that installs both Wine and IE with minimal fuss. It’s called IEs4Linux. To make the process as painless as possible there’s a step by step guide available here. The most important thing to remember is to carry out the install as a normal user, i.e. NOT the root user.

If you’re running Ubuntu Gutsy then for step 2 add the following lines to /etc/apt/sources.list

deb http://de.archive.ubuntu.com/ubuntu gutsy universe
deb http://wine.budgetdedicated.com/apt gutsy main

When asked if I wanted to install IE5.5 or IE5.0 I said no. That meant that only IE 6 was installed. Installing all three isn’t a problem but I had no need for 5.0 and 5.5.

Once the process has finished you should have an Internet Explorer icon on your desktop.

Installing the Java Runtime Environment Plug-in for IE
This was the part that I was a little unsure about. I thought getting IE to run was an achievement but I never thought the IE JRE plug-in would work. As luck would have it I came across this post by Ranjit Mathew that was exactly what I needed.

Following Ranjit’s post here are the steps I carried out…

i) Go to the Sun website and download the latest version of the Windows 1.5 JRE. The reason for using 1.5 and not the latest 1.6 is that the ROS website states that they only support Sun 1.5 on IE6. The 1.6 version may work but I didn’t want to tempt faith.

ii) Open a command prompt and execute the following lines,

export WINEPREFIX=$HOME/.ies4linux/ie6
wine jre-1_5_0_13-windows-i586-p.exe

iii) I was having some problems with the entire screen blacking out when I’d visit a page with a Java applet on it. If you have the same problem open a command prompt and execute these commands…

export WINEPREFIX=$HOME/.ies4linux/ie6
regedit

Go to the key HKEY_CURRENT_USER\Software\JavaSoft\Java2D\1.5.0_13 and set the property “DXAcceleration” to 0.

Installing The ROS Software
When you visit the ROS website for the first time you’ll have to install the KCrypto software. KCrypto is the Java code that handles the secure transfer of data between your browser and the NIB servers. The first time I tried to install it it failed. The second time it worked fine.

Installing your ROS Certificates
Your ROS security certificates are held in the folder C:\ROS on your Windows machine. Copy this entire folder from your Windows machine into the folder $HOME/.ies4linux/ie6/drive_c. When you restart your IE browser you should see your user id appear on the ROS logon page.

Installing you NIB UserID File
i) Logon to your NIB account on your Windows machine
ii) Click on “Settings” at the top of the page and then “Security” in the left hand menu
iii) Select the function “Back up user ID” and click OK
iv) On the next screen click OK. Take the file that’s downloaded and go back to your Linux machine
v) Start up IE and go to the logon page
vi) Select “Search for user id” just under the userid and password fields. Browse to where you have the file downloaded in step iv, select the second radio button (i.e. copy to a local location) and click OK

That’s it. One step closer to going Linux full time.

The last time I installed MythTV I had the same problem with XMLTV. I don’t know if it’s something that I keep missing but after the installation mythfilldatabase never seems to works properly. The problem is that the XMLTV file containing the list of channels to fetch program information for never gets created. Luckily it’s easy enough to fix. What you do is take the name of the Video Source you setup in the MythTV Backend Setup program (in my case NTL) and then create a file in the directory $HOME/.mythtv called <video source name>.xmltv (e.g. NTL.xmltv in my case). When I refer to $HOME here I’m referring to the home directory of the user that you’re asked to create during the Mythbuntu installation. Within that file you list the XMLTV channel ids you want to retrieve program information for. Here’s what I have…

channel northern-ireland.bbc1.bbc.co.uk
channel northern-ireland.bbc2.bbc.co.uk
channel channel4.com
channel discoveryeurope.com
channel e4.channel4.com
channel livingtv.co.uk
channel mtv.co.uk
channel paramountcomedy.com
channel rte-1.rte.ie
channel rte2.rte.ie
channel 1.setanta.com
channel sky-news.sky.com
channel sky-one.sky.com
channel tg4.ie
channel tv3.ie
channel utvlive.com
channel nickelodeon.co.uk

This is the program listing for NTL’s analogue network in Dublin. Unfortunately (I suppose) Channel 6 isn’t available from the Radio Times XMLTV feed.

The second problem I had was configuring my wireless network card. The card I have is a Linksys WMP54G (version 4, PCI id 1814:0201). What I did was follow the instructions on this page https://help.ubuntu.com/community/WifiDocs/Driver/Ndiswrapper. When it comes to installing the windows drivers I used the files from the directory /Drivers/WMP54Gv4/2KXP on the installation CD that I got with the card. At the end of the process the card still wasn’t working. The problem was that a kernel module shipped with Ubuntu, namely rt2500pci, was getting loaded before (and hence interfering with) the module I wanted to load, i.e. ndiswrapper. To fix the problem I blacklisted rt2500pci and rebooted. The line I added to /etc/modprobe.d/blacklist was blacklist rt2500pci.

That’s it, a relatively easy install and nowhere near as timeconsuming or complicated as perfoming a MythTV installation from scratch.

P.S. another useful resource if you’re stuck is https://help.ubuntu.com/community/WifiDocs/WirelessTroubleShootingGuide.

Very often it’s useful to see the actual text in this field. One way to do this is to give the user the option to have a quick peek behind the masked characters by clicking on a checkbox. After adding this feature to UPM I thought it might share it since it used a feature of JPasswordField I hadn’t seen before.

The code below shows the action listener I placed on the checkbox used to toggle the password visibility.

hidePasswordCheckbox.addItemListener(new ItemListener() {
    public void itemStateChanged(ItemEvent e) {
        if (e.getStateChange() == ItemEvent.SELECTED) {
            httpProxyPassword.setEchoChar('*');
        } else {
             httpProxyPassword.setEchoChar((char) 0);
        }
    }
});

Basically the setEchoChar() method sets the character that’s displayed instead of the actual character. When you set this value to “0″ JPasswordField doesn’t perform any masking. It’s that simple.

org.hibernate.SessionException: Session is closed!
   at org.hibernate.impl.AbstractSessionImpl.errorIfClosed(AbstractSessionImpl.java:49)
   at org.hibernate.impl.SessionImpl.beginTransaction(SessionImpl.java:1319)
   at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
   at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
   at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
   at java.lang.reflect.Method.invoke(Unknown Source)
   at org.hibernate.context.ThreadLocalSessionContext$TransactionProtectionWrapper.invoke(ThreadLocalSessionContext.java:301)
   at $Proxy0.beginTransaction(Unknown Source)
   ....

The reason for this is that Hibernate is using “thread” managed sessions. With this type of session management Hibernate manages the session for you. When you first attempt to use a session Hibernate will create one and attach it to your local thread. When you commit the transaction in the session Hibernate will automatically close the session meaning it can’t be reused.

To get around this problem the best option is to use “managed” sessions. With managed sessions you’re in full control of creating, flushing, commiting, and closing sessions. Here’s how.

In your hibernate.cfg.xml change the property “current_session_context_class” to “managed”.

To create a session and start a transaction in that session do this…

   org.hibernate.classic.Session session = HibernateUtil.getSessionFactory().openSession();
   session.setFlushMode(FlushMode.MANUAL);
   ManagedSessionContext.bind(session);
   session.beginTransaction();

To commit a transaction in the session do this…

   ManagedSessionContext.unbind(HibernateUtil.getSessionFactory());
   session.flush();
   session.getTransaction().commit();
   session.close();

To use this code in unit tests I created this base unit test class that all my unit tests extend. Whenever I want to create a new session/transaction I call the method createNewSessionAndTransaction(). To commit the session’s transaction I call the method commitTransaction().

import org.hibernate.FlushMode;
import org.hibernate.Session;
import org.hibernate.context.ManagedSessionContext;
import util.HibernateUtil;
import junit.framework.TestCase;

/**
 * Abstract unit test with helper methods for managed session control
 */
public abstract class ManagedSessionUnitTest extends TestCase {

   /**
    * Create a new Session.
    *
    * For this method to work, the application managed session strategy has to
    * be enabled. This basically means that the life of a session is controlled
    * by you and and not by Hibernate.
    *
    * To enable the application managed session strategy set the property
    * hibernate.current_session_context_class to "managed".
    *
    * Within this method we create a new session and set the flush mode to
    * MANUAL. This ensures that we have full control over when the session is
    * flushed to the database.
    */
   protected org.hibernate.Session createNewSession() {
      org.hibernate.classic.Session session = HibernateUtil.getSessionFactory().openSession();
      session.setFlushMode(FlushMode.MANUAL);
      ManagedSessionContext.bind(session);
      return (org.hibernate.Session) session;
   }

   /**
    * Start a new Transaction in the given session
    * @param session The session to create the transaction in
    */
   protected void startNewTransaction(Session session) {
      session.beginTransaction();
   }

   /**
    * Shortcut method that creates a new session and begins a transaction in it
    * @return A new session with a transaction started
    */
   protected org.hibernate.Session createNewSessionAndTransaction() {
      Session session = createNewSession();
      startNewTransaction(session);
      return session;
   }

   /**
    * Commit the transaction within the given session. This method unbinds
    * the session from the session context (ManagedSessionContext), flushes
    * the session, commmits the session and then closes the session
    * @param session The session with the transaction to commit
    */
   protected void commitTransaction(Session session) {
      ManagedSessionContext.unbind(HibernateUtil.getSessionFactory());
      session.flush();
      session.getTransaction().commit();
      session.close();
   }

}

I wanted a backup medium that I could use on both machines. I’ve never been a big fan of tape backup solutions. They’re just too expensive and difficult to use in a home environment. Because I don’t have a huge amount of stuff to backup I decided to go with an external harddrive. They’re cheap, easy to setup and I could use it on both machines. In the end I went for a WD My Book. It’s a little bit more expensive then a basic harddrive and enclosure but not so much that it turned me off. I went with the Premium version because it had the Firewire connection. If I were buying it again I don’t think I’d bothered with the Premium edition because when all you’re backing up is thousands of relatively small files it’s the processing time that slows the process down not the speed of the connection to the harddrive.

With the medium chosen I then had a look around for some backup software. I wanted something that was opensource and cross platform so that I only had to learn how to use one program. There’s very little out there that’s easy to understand and use. The basic programs just don’t instill any confidence while the feature rich programs are just too complicated and more suited to business environments. The most popular program seems to be AMANDA. The problem with AMANDA is that it’s far too complicated for a simple home backup solution (in my mind anyway). The program I finally settled for was rdiff-backup. It’s not too complicated and has all the basic features I need, it’s open source, it’s cross platform and it has a user community.

Something that I sort of forgot about up to this point was the filesystem to use on the external harddrive. If you’re only backing up a Windows machine then I suggest you format your target backup drive as NTFS. If you’re on Mac then use HFS and if you’re on Linux use ext3 or whatever you prefer. If however you want to be able to see the same partition from both Windows and Mac (like I do) then you MUST use FAT32. The reason for this is because OS X cannot write to NTFS (only read) and Windows certainly cannot write or read HFS. The only common filesystem that the two OSes can write to is FAT32. The only potential problem with this is that FAT32 only supports files up to 4Gb in size. For me this isn’t a problem but if you have a lot of videos you may find that some exceed this limit. If this happens then you could just create two partitions on the external harddrive, one HFS for your Mac backups and one NTFS for your Windows backups. You won’t be able to see the HFS partition from Windows but if that’s not a problem for you then this might be the best approach all round. The other drawback with FAT32 is that Windows will only allow you to create a partition that’s 32Gb in size. The strange thing is that Windows can reference a FAT32 partition that’s up to 2Tb in size. To create a partition greater that 32Gb WD have a tool for the My Book called the WD FAT32 Formatter. There’s probably generic tools out there that will do this for any harddrive.

rdiff-backup on Mac OS X
The first machine I backed up was the iMac. Because I might be restoring onto a completely clean machine I created a folder on the external harddrive with all the software that’s needed to install and run rdiff-backup. Into this directory I put…

• rdiff-backup 1.1.5
• librsync 0.9.7
• A patch I needed get rdiff-backup working on OS X (I got the patch from this useful post http://katastrophos.net/andre/blog/?p=19)

Installing librsync on Mac OS X
=> tar -xzvf librsync-0.9.7.tar.gz
=> cd librsync-0.9.7
=> ./configure
=> make all
=> make check (not necessary)
=> sudo make install

Installing rdiff-backup on Mac OS X
=> tar -xzvf rdiff-backup-1.1.5.tar.gz
=> cp fs_abilities.py.patch rdiff-backup-1.1.5/rdiff_backup
=> cd rdiff-backup-1.1.5/rdiff_backup
=> patch < fs_abilities.py.patch
=> cd ..
=> sudo python setup.py install
(Create symbolic links in your bin directory for the two rdiff programs)
=> sudo ln -s /System/Library/Frameworks/Python.framework/Versions/2.3/bin/rdiff-backup /usr/bin/rdiff-backup
=> sudo ln -s /System/Library/Frameworks/Python.framework/Versions/2.3/bin/rdiff-backup-statistics /usr/bin/rdiff-backup-statistics

Preparing rdiff-backup on Mac OS X
rdiff-backup lets you explicitly list the files and directories you want to backup in an external file called the “globbing filelist”. Here’s what’s in mine…

/Users/adriansmith/Desktop
/Users/adriansmith/dev
/Users/adriansmith/Documents
/Users/adriansmith/Movies
/Users/adriansmith/Music
/Users/adriansmith/Pictures
/Users/adriansmith/Shared
/Users/adriansmith/Sites

A very important point to note (although more important on the windows platform) is that this file should be saved in UNIX format. If it’s saved in Windows format rdiff-backup will not read it correctly.

Running rdiff-backup on Mac OS X

rdiff-backup -v5 --print-statistics --include-globbing-filelist '/Volumes/My Book/instructions/mac/files-to-include.txt' --exclude-special-files --exclude / / '/Volumes/My Book/mac'

-v5 : Verbosity level
–print-statistics : When the backup is finished a summary will be displayed
–include-globbing-filelist : Followed by the file that contains the list of files & directories to backup
–exclude-special-files : Exclude all device files, fifo files, socket files, and symbolic links
–exclude / : Excludes everything from the root directory (weird I know but by including this you’re saying that you only want to include the files/directories specifically mentioned in the globbing file
/ : The source directory
‘/Volumes/My Book/mac’ : The destination directory, in this case a directory called mac on my external harddrive

rdiff-backup on Windows XP
On my Windows machine I again created a folder on the external harddrive containing all the software needed to get rdiff-backup up and running. It contains…

• Cygwin (because rdiff-backup requires a POSIX operating system, like Linux or Mac OS X)
• rdiff-backup 1.1.5
• librsync 0.9.7
• A patch needed get rdiff-backup working on Windows

Installing Cygwin on Windows XP
=> Run setup.exe
=> Go with the default selected packages to install but select the following as well,

• Devel/ autoconf, automake, binutils, gcc, make, patchutils
• Interpreters/ python
• Web/ wget

Installing librsync on Windows XP
=> tar -xzvf librsync-0.9.7.tar.gz
=> cd librsync-0.9.7
=> ./configure –prefix=/usr –bindir=/bin –libdir=/lib
=> make all
=> make install

Installing rdiff-backup on Windows XP
=> tar -xzvf rdiff-backup-1.1.5.tar.gz
=> cp rpath-fsync.patch rdiff-backup-1.1.5/rdiff_backup
=> cd rdiff-backup-1.1.5/rdiff_backup
=> patch < rpath-fsync.patch
=> cd ..
=> python setup.py install

Preparing rdiff-backup on Windows XP
To run rdiff-backup I again created a file containing all the files and directories I wanted to backup. Here’s what it contains…

/cygdrive/c/Documents and Settings/Adrian Smith/My Documents
/cygdrive/c/projects

IMPORTANT: This file MUST be saved in UNIX format. If you use Notepad or any other program that saves in Windows format rdiff-backup will not work. I use PFE but there are plenty of other equally capable editors out there.

Running rdiff-backup on Windows XP
Finally, to run rdiff-backup…

rdiff-backup -v5 --print-statistics --include-globbing-filelist /cygdrive/e/instructions/windows/files-to-include.txt --exclude /cygdrive/c /cygdrive/c /cygdrive/e/dell

• Make sure you have MinGW installed. I’m using version 4.1.0.
• Download the file qt-win-opensource-desktop-4.0.0.zip from Trolltech’s website
• Extract it to the directory where you want to install Qt, e.g. c:\qt\4.0.0
• Open a command prompt and cd to the directory c:\qt\4.0.0
• Run the configure program like this, configure -platform win32-g++. You have to use the win32-g++ platform (MinGW) because win32-msvc (MS Visual Studio) is not supported in the open source version of Qt (see here for a lively debat on the topic). If you try running configure -platform win32-msvc you’ll get to accept the license agreement but the configure program will just exit straight away with no explaination of what happened
• Ensure that the MinGW bin directory is in your PATH environment variable. It’s very important that if you have MSYS installed that it is NOT in your PATH. If it is then the next step will fail because it picks up the cd program from MSYS and fails when trying to cd to windows formatted paths (i.e. paths using \ instead of /)
• Run mingw32-make. Note that this step takes quite some time (> 1 hour). Note also that you’ll need at about 2GB of disk space to hold all the files built as part of this step.
• Finally add c:\qt\4.0.0\bin to your PATH environment variable. Ensure also that MinGW is on your PATH so that the Qt applications can find the MinGW binaries at runtime.

1. Go to http://www.sleepycat.com/download/index.shtml and download BerkeleyDB 4.2.52
2. Download the patches numbered like this patch.4.2.52.?
3. Extract the BerkeleyDB compressed file
4. Copy all the patch files into the base directory just extracted
5. Apply the patches individually using…patch -p0 < [patchfile]
6. cd into the build_unix directory in the extracted directory
7. Run…../dist/configure
8. Run…make
9. Ensure you’re logged in as root and run…make install (installs to /usr/local/BerkeleyDB.4.2)
10. Add the line /usr/local/BerkeleyDB.4.2/lib to the file/etc/ld.so.conf
11. Run ldconfig to update the library cache with the BerkeleyDB libraries

Install Apache

1. Ensure that the following packages are installed. If they’re not just do an apt-get install to download and install them…autoconf libtool openssl libssl-dev zlib1g zlib1g-dev
2. Download tha latest version of Apache 2 from http://httpd.apache.org/download.cgi
3. Extract the Apache compressed file
4. cd in the extracted directory
5. Run…./configure –enable-dav –enable-so –enable-ssl –with-dbm=db4 –with-berkeley-db=/usr/local/BerkeleyDB.4.2 –enable-deflate
6. Run…make
7. Ensure you’re logged in as root and run…make install (installs to /usr/local/apache2)
8. Edit the file /usr/local/apache2/conf/httpd.conf and update the User & Group tags to www-data (Assuming of course that you have that user & group)

Install Subversion

1. Download the latest version of Subversion from http://subversion.tigris.org/getting_subversion.html
2. Extract the Subversion compressed file
3. Run…./configure –with-ssl –with-berkeley-db=/usr/local/BerkeleyDB.4.2 –with-zlib
4. Run…make
5. Ensure you’re logged in as root and run…make install

Configure Apache & Subversion

1. Create a directory to hold your repositories, something like /usr/local/svn
2. Change the ownership on the directory to the www-user user (or whoever you set the User tag to in httpd.conf)
3. Add users to Apache using this command…htpasswd -cm /etc/svn-auth-file <name>. Leave out the c switch if the file already exists
4. Add the following section to /usr/local/apache2/conf/httpd.conf

   LoadModule dav_svn_module     modules/mod_dav_svn.so
   DeflateFilterNote Input instream
   DeflateFilterNote Output outstream
   DeflateFilterNote Ratio ratio
   LogFormat '"%r" %{outstream}n/%{instream}n (%{ratio}n%%)' deflate
   CustomLog logs/deflate_log deflate
   
   <Location /svn>
   DAV svn
   SVNParentPath /usr/local/svn
   AuthType Basic
   AuthName "Subversion Repository"
   AuthUserFile /etc/svn-auth-file
   Require valid-user
   SetOutputFilter DEFLATE
   SetInputFilter DEFLATE
   </Location>
   

   These config entries will password protect your repositry and allow for data sent between clients and Apache to be compressed

Starting Apache

1. Ensure you’re logged in as root and run…/usr/local/apache2/bin/apachectl start

The next step is to try and get Apache using SSL because Basic authentication uses plain text when transmitting the password from the client to the server. This article seems to do the trick.