Makes it all compile nicely. Added db-util sources (that are included in...

Makes it all compile nicely. Added db-util sources (that are included in Openfire as a JAR). Note that we need a Java 1.6 compiler to compile - a 1.7 compiler won't work because of java.sql extensions in db-utils.

git-svn-id: http://svn.igniterealtime.org/svn/repos/openfire/branches/maven-externalsbased@13066 b35dd754-fafc-0310-a699-88a17e54d16e

dbutil/pom.xml

+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <artifactId>parent</artifactId>
+    <groupId>org.igniterealtime.openfire</groupId>
+    <version>4.0.0-SNAPSHOT</version>
+    <relativePath>..</relativePath>
+  </parent>
+  <artifactId>dbutil</artifactId>
+</project>
\ No newline at end of file

dbutil/src/main/java/org/jivesoftware/database/AbstractConnection.java

+/**
+ * $RCSfile$
+ * $Revision: 37 $
+ * $Date: 2004-10-20 23:08:43 -0700 (Wed, 20 Oct 2004) $
+ *
+ * Copyright (C) 2004 Jive Software. All rights reserved.
+ *
+ * This software is published under the terms of the GNU Public License (GPL),
+ * a copy of which is included in this distribution.
+ */
+
+package org.jivesoftware.database;
+
+import java.sql.*;
+import java.util.Map;
+import java.util.Properties;
+
+/**
+ * An implementation of the Connection interface that wraps an underlying
+ * Connection object.
+ *
+ * @author Gaston Dombiak
+ */
+public abstract class AbstractConnection implements Connection {
+
+    protected Connection connection;
+
+	public AbstractConnection(Connection connection) {
+        this.connection = connection;
+    }
+
+    public <T> T unwrap(Class<T> iface) throws SQLException {
+		return connection.unwrap(iface);
+	}
+
+	public boolean isWrapperFor(Class<?> iface) throws SQLException {
+		return connection.isWrapperFor(iface);
+	}
+
+	public Statement createStatement() throws SQLException {
+		return connection.createStatement();
+	}
+
+	public PreparedStatement prepareStatement(String sql) throws SQLException {
+		return connection.prepareStatement(sql);
+	}
+
+	public CallableStatement prepareCall(String sql) throws SQLException {
+		return connection.prepareCall(sql);
+	}
+
+	public String nativeSQL(String sql) throws SQLException {
+		return connection.nativeSQL(sql);
+	}
+
+	public void setAutoCommit(boolean autoCommit) throws SQLException {
+		connection.setAutoCommit(autoCommit);
+	}
+
+	public boolean getAutoCommit() throws SQLException {
+		return connection.getAutoCommit();
+	}
+
+	public void commit() throws SQLException {
+		connection.commit();
+	}
+
+	public void rollback() throws SQLException {
+		connection.rollback();
+	}
+
+	public void close() throws SQLException {
+		connection.close();
+	}
+
+	public boolean isClosed() throws SQLException {
+		return connection.isClosed();
+	}
+
+	public DatabaseMetaData getMetaData() throws SQLException {
+		return connection.getMetaData();
+	}
+
+	public void setReadOnly(boolean readOnly) throws SQLException {
+		connection.setReadOnly(readOnly);
+	}
+
+	public boolean isReadOnly() throws SQLException {
+		return connection.isReadOnly();
+	}
+
+	public void setCatalog(String catalog) throws SQLException {
+		connection.setCatalog(catalog);
+	}
+
+	public String getCatalog() throws SQLException {
+		return connection.getCatalog();
+	}
+
+	public void setTransactionIsolation(int level) throws SQLException {
+		connection.setTransactionIsolation(level);
+	}
+
+	public int getTransactionIsolation() throws SQLException {
+		return connection.getTransactionIsolation();
+	}
+
+	public SQLWarning getWarnings() throws SQLException {
+		return connection.getWarnings();
+	}
+
+	public void clearWarnings() throws SQLException {
+		connection.clearWarnings();
+	}
+
+	public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
+		return connection.createStatement(resultSetType, resultSetConcurrency);
+	}
+
+	public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
+			throws SQLException {
+		return connection.prepareStatement(sql, resultSetType, resultSetConcurrency);
+	}
+
+	public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
+		return connection.prepareCall(sql, resultSetType, resultSetConcurrency);
+	}
+
+	public Map<String, Class<?>> getTypeMap() throws SQLException {
+		return connection.getTypeMap();
+	}
+
+	public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
+		connection.setTypeMap(map);
+	}
+
+	public void setHoldability(int holdability) throws SQLException {
+		connection.setHoldability(holdability);
+	}
+
+	public int getHoldability() throws SQLException {
+		return connection.getHoldability();
+	}
+
+	public Savepoint setSavepoint() throws SQLException {
+		return connection.setSavepoint();
+	}
+
+	public Savepoint setSavepoint(String name) throws SQLException {
+		return connection.setSavepoint(name);
+	}
+
+	public void rollback(Savepoint savepoint) throws SQLException {
+		connection.rollback(savepoint);
+	}
+
+	public void releaseSavepoint(Savepoint savepoint) throws SQLException {
+		connection.releaseSavepoint(savepoint);
+	}
+
+	public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
+			throws SQLException {
+		return connection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
+	}
+
+	public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
+			int resultSetHoldability) throws SQLException {
+		return connection.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
+	}
+
+	public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency,
+			int resultSetHoldability) throws SQLException {
+		return connection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
+	}
+
+	public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
+		return connection.prepareStatement(sql, autoGeneratedKeys);
+	}
+
+	public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
+		return connection.prepareStatement(sql, columnIndexes);
+	}
+
+	public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
+		return connection.prepareStatement(sql, columnNames);
+	}
+
+	public Clob createClob() throws SQLException {
+		return connection.createClob();
+	}
+
+	public Blob createBlob() throws SQLException {
+		return connection.createBlob();
+	}
+
+	public NClob createNClob() throws SQLException {
+		return connection.createNClob();
+	}
+
+	public SQLXML createSQLXML() throws SQLException {
+		return connection.createSQLXML();
+	}
+
+	public boolean isValid(int timeout) throws SQLException {
+		return connection.isValid(timeout);
+	}
+
+	public void setClientInfo(String name, String value) throws SQLClientInfoException {
+		connection.setClientInfo(name, value);
+	}
+
+	public void setClientInfo(Properties properties) throws SQLClientInfoException {
+		connection.setClientInfo(properties);
+	}
+
+	public String getClientInfo(String name) throws SQLException {
+		return connection.getClientInfo(name);
+	}
+
+	public Properties getClientInfo() throws SQLException {
+		return connection.getClientInfo();
+	}
+
+	public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
+		return connection.createArrayOf(typeName, elements);
+	}
+
+	public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
+		return connection.createStruct(typeName, attributes);
+	}
+}

dbutil/src/main/java/org/jivesoftware/database/PreparedStatementWrapper.java

+/**
+ * $RCSfile$
+ * $Revision: 37 $
+ * $Date: 2004-10-20 23:08:43 -0700 (Wed, 20 Oct 2004) $
+ *
+ * Copyright (C) 2004 Jive Software. All rights reserved.
+ *
+ * This software is published under the terms of the GNU Public License (GPL),
+ * a copy of which is included in this distribution.
+ */
+
+package org.jivesoftware.database;
+
+import java.sql.*;
+import java.math.BigDecimal;
+import java.io.InputStream;
+import java.io.Reader;
+import java.util.Calendar;
+import java.net.URL;
+
+/**
+ * An implementation of the PreparedStatement interface that wraps an underlying
+ * PreparedStatement object.
+ *
+ * @author Gaston Dombiak
+ */
+public abstract class PreparedStatementWrapper extends StatementWrapper
+        implements PreparedStatement {
+
+    protected PreparedStatement pstmt;
+
+    public PreparedStatementWrapper(PreparedStatement pstmt) {
+        super(pstmt);
+        this.pstmt = pstmt;
+    }
+
+    public ResultSet executeQuery() throws SQLException {
+        return pstmt.executeQuery();
+    }
+
+    public int executeUpdate() throws SQLException {
+        return pstmt.executeUpdate();
+    }
+
+    public void setNull(int parameterIndex, int sqlType) throws SQLException {
+        pstmt.setNull(parameterIndex, sqlType);
+    }
+
+    public void setBoolean(int parameterIndex, boolean x) throws SQLException {
+        pstmt.setBoolean(parameterIndex, x);
+    }
+
+    public void setByte(int parameterIndex, byte x) throws SQLException {
+        pstmt.setByte(parameterIndex, x);
+    }
+
+    public void setShort(int parameterIndex, short x) throws SQLException {
+        pstmt.setShort(parameterIndex, x);
+    }
+
+    public void setInt(int parameterIndex, int x) throws SQLException {
+        pstmt.setInt(parameterIndex, x);
+    }
+
+    public void setLong(int parameterIndex, long x) throws SQLException {
+        pstmt.setLong(parameterIndex, x);
+    }
+
+    public void setFloat(int parameterIndex, float x) throws SQLException {
+        pstmt.setFloat(parameterIndex, x);
+    }
+
+    public void setDouble(int parameterIndex, double x) throws SQLException {
+        pstmt.setDouble(parameterIndex, x);
+    }
+
+    public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
+        pstmt.setBigDecimal(parameterIndex, x);
+    }
+
+    public void setString(int parameterIndex, String x) throws SQLException {
+        pstmt.setString(parameterIndex, x);
+    }
+
+    public void setBytes(int parameterIndex, byte x[]) throws SQLException {
+        pstmt.setBytes(parameterIndex, x);
+    }
+
+    public void setDate(int parameterIndex, Date x) throws SQLException {
+        pstmt.setDate(parameterIndex, x);
+    }
+
+    public void setTime(int parameterIndex, Time x) throws SQLException {
+        pstmt.setTime(parameterIndex, x);
+    }
+
+    public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
+        pstmt.setTimestamp(parameterIndex, x);
+    }
+
+    public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
+        pstmt.setAsciiStream(parameterIndex, x, length);
+    }
+
+    @Deprecated public void setUnicodeStream(int parameterIndex, InputStream x, int length)
+            throws SQLException {
+        pstmt.setUnicodeStream(parameterIndex, x, length);
+    }
+
+    public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
+        pstmt.setBinaryStream(parameterIndex, x, length);
+    }
+
+    public void clearParameters() throws SQLException {
+        pstmt.clearParameters();
+    }
+
+    public void setObject(int parameterIndex, Object x, int targetSqlType, int scale)
+            throws SQLException {
+        pstmt.setObject(parameterIndex, x, targetSqlType, scale);
+    }
+
+    public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
+        pstmt.setObject(parameterIndex, x, targetSqlType);
+    }
+
+    public void setObject(int parameterIndex, Object x) throws SQLException {
+        pstmt.setObject(parameterIndex, x);
+    }
+
+    public boolean execute() throws SQLException {
+        return pstmt.execute();
+    }
+
+    public void addBatch() throws SQLException {
+        pstmt.addBatch();
+    }
+
+    public void setCharacterStream(int parameterIndex, Reader reader, int length)
+            throws SQLException {
+        pstmt.setCharacterStream(parameterIndex, reader, length);
+    }
+
+    public void setRef(int i, Ref x) throws SQLException {
+        pstmt.setRef(i, x);
+    }
+
+    public void setBlob(int i, Blob x) throws SQLException {
+        pstmt.setBlob(i, x);
+    }
+
+    public void setClob(int i, Clob x) throws SQLException {
+        pstmt.setClob(i, x);
+    }
+
+    public void setArray(int i, Array x) throws SQLException {
+        pstmt.setArray(i, x);
+    }
+
+    public ResultSetMetaData getMetaData() throws SQLException {
+        return pstmt.getMetaData();
+    }
+
+    public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
+        pstmt.setDate(parameterIndex, x, cal);
+    }
+
+    public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
+        pstmt.setTime(parameterIndex, x, cal);
+    }
+
+    public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
+        pstmt.setTimestamp(parameterIndex, x, cal);
+    }
+
+    public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException {
+        pstmt.setNull(paramIndex, sqlType, typeName);
+    }
+
+    public void setURL(int parameterIndex, URL x) throws SQLException {
+        pstmt.setURL(parameterIndex, x);
+    }
+
+    public ParameterMetaData getParameterMetaData() throws SQLException {
+        return pstmt.getParameterMetaData();
+    }
+
+	public void setRowId(int parameterIndex, RowId x) throws SQLException {
+		pstmt.setRowId(parameterIndex, x);
+	}
+
+	public void setNString(int parameterIndex, String value) throws SQLException {
+		pstmt.setNString(parameterIndex, value);
+	}
+
+	public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
+		pstmt.setNCharacterStream(parameterIndex, value, length);	
+	}
+
+	public void setNClob(int parameterIndex, NClob value) throws SQLException {
+		pstmt.setNClob(parameterIndex, value);		
+	}
+
+	public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
+		pstmt.setClob(parameterIndex, reader, length);
+	}
+
+	public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
+		pstmt.setBlob(parameterIndex, inputStream, length);
+	}
+
+	public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
+		pstmt.setNClob(parameterIndex, reader, length);
+	}
+
+	public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
+		pstmt.setSQLXML(parameterIndex, xmlObject);
+	}
+
+	public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
+		pstmt.setAsciiStream(parameterIndex, x, length);
+	}
+
+	public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
+		pstmt.setBinaryStream(parameterIndex, x, length);
+	}
+
+	public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
+		pstmt.setCharacterStream(parameterIndex, reader, length);
+	}
+
+	public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
+		pstmt.setAsciiStream(parameterIndex, x);
+	}
+
+	public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
+		pstmt.setBinaryStream(parameterIndex, x);
+	}
+
+	public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
+		pstmt.setCharacterStream(parameterIndex, reader);
+	}
+
+	public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
+		pstmt.setNCharacterStream(parameterIndex, value);		
+	}
+
+	public void setClob(int parameterIndex, Reader reader) throws SQLException {
+		pstmt.setClob(parameterIndex, reader);
+	}
+
+	public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
+		pstmt.setBlob(parameterIndex, inputStream);
+	}
+
+	public void setNClob(int parameterIndex, Reader reader) throws SQLException {
+		pstmt.setNClob(parameterIndex, reader);
+	}
+}

dbutil/src/main/java/org/jivesoftware/database/ProfiledConnectionEntry.java

+/**
+ * $RCSfile$
+ * $Revision: 37 $
+ * $Date: 2004-10-20 23:08:43 -0700 (Wed, 20 Oct 2004) $
+ *
+ * Copyright (C) 2004 Jive Software. All rights reserved.
+ *
+ * This software is published under the terms of the GNU Public License (GPL),
+ * a copy of which is included in this distribution.
+ */
+
+package org.jivesoftware.database;
+
+/**
+ * Simple class for tracking profiling stats for individual SQL queries.
+ *
+ * @author Jive Software
+ */
+public class ProfiledConnectionEntry {
+    /**
+     * The SQL query.
+     */
+    public String sql;
+
+    /**
+     * Number of times the query has been executed.
+     */
+    public int count;
+
+    /**
+     * The total time spent executing the query (in milliseconds).
+     */
+    public int totalTime;
+
+    public ProfiledConnectionEntry(String sql) {
+        this.sql = sql;
+        count = 0;
+        totalTime = 0;
+    }
+}

dbutil/src/main/java/org/jivesoftware/database/StatementWrapper.java

+/**
+ * $RCSfile$
+ * $Revision: 37 $
+ * $Date: 2004-10-20 23:08:43 -0700 (Wed, 20 Oct 2004) $
+ *
+ * Copyright (C) 2004 Jive Software. All rights reserved.
+ *
+ * This software is published under the terms of the GNU Public License (GPL),
+ * a copy of which is included in this distribution.
+ */
+
+package org.jivesoftware.database;
+
+import java.sql.*;
+
+/**
+ * An implementation of the Statement interface that wraps an underlying
+ * Statement object.
+ *
+ * @author Gaston Dombiak
+ */
+public abstract class StatementWrapper implements Statement {
+
+    protected Statement stmt;
+
+    /**
+     * Creates a new StatementWrapper that wraps <tt>stmt</tt>.
+     *
+     * @param stmt
+     */
+    public StatementWrapper(Statement stmt) {
+        this.stmt = stmt;
+    }
+
+    public ResultSet executeQuery(String sql) throws SQLException {
+        return stmt.executeQuery(sql);
+    }
+
+    public int executeUpdate(String sql) throws SQLException {
+        return stmt.executeUpdate(sql);
+    }
+
+    public void close() throws SQLException {
+        stmt.close();
+    }
+
+    public int getMaxFieldSize() throws SQLException {
+        return stmt.getMaxFieldSize();
+    }
+
+    public void setMaxFieldSize(int max) throws SQLException {
+        stmt.setMaxFieldSize(max);
+    }
+
+    public int getMaxRows() throws SQLException {
+        return stmt.getMaxRows();
+    }
+
+    public void setMaxRows(int max) throws SQLException {
+        stmt.setMaxRows(max);
+    }
+
+    public void setEscapeProcessing(boolean enable) throws SQLException {
+        stmt.setEscapeProcessing(enable);
+    }
+
+    public int getQueryTimeout() throws SQLException {
+        return stmt.getQueryTimeout();
+    }
+
+    public void setQueryTimeout(int seconds) throws SQLException {
+        stmt.setQueryTimeout(seconds);
+    }
+
+    public void cancel() throws SQLException {
+        stmt.cancel();
+    }
+
+    public SQLWarning getWarnings() throws SQLException {
+        return stmt.getWarnings();
+    }
+
+    public void clearWarnings() throws SQLException {
+        stmt.clearWarnings();
+    }
+
+    public void setCursorName(String name) throws SQLException {
+        stmt.setCursorName(name);
+    }
+
+    public boolean execute(String sql) throws SQLException {
+        return stmt.execute(sql);
+    }
+
+    public ResultSet getResultSet() throws SQLException {
+        return stmt.getResultSet();
+    }
+
+    public int getUpdateCount() throws SQLException {
+        return stmt.getUpdateCount();
+    }
+
+    public boolean getMoreResults() throws SQLException {
+        return stmt.getMoreResults();
+    }
+
+    public void setFetchDirection(int direction) throws SQLException {
+        stmt.setFetchDirection(direction);
+    }
+
+    public int getFetchDirection() throws SQLException {
+        return stmt.getFetchDirection();
+    }
+
+    public void setFetchSize(int rows) throws SQLException {
+        stmt.setFetchSize(rows);
+    }
+
+    public int getFetchSize() throws SQLException {
+        return stmt.getFetchSize();
+    }
+
+    public int getResultSetConcurrency() throws SQLException {
+        return stmt.getResultSetConcurrency();
+    }
+
+    public int getResultSetType() throws SQLException {
+        return stmt.getResultSetType();
+    }
+
+    public void addBatch(String sql) throws SQLException {
+        stmt.addBatch(sql);
+    }
+
+    public void clearBatch() throws SQLException {
+        stmt.clearBatch();
+    }
+
+    public int[] executeBatch() throws SQLException {
+        return stmt.executeBatch();
+    }
+
+    public Connection getConnection() throws SQLException {
+        return stmt.getConnection();
+    }
+
+    public boolean getMoreResults(int current) throws SQLException {
+        return stmt.getMoreResults(current);
+    }
+
+    public ResultSet getGeneratedKeys() throws SQLException {
+        return stmt.getGeneratedKeys();
+    }
+
+    public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
+        return stmt.executeUpdate(sql, autoGeneratedKeys);
+    }
+
+    public int executeUpdate(String sql, int columnIndexes[]) throws SQLException {
+        return stmt.executeUpdate(sql, columnIndexes);
+    }
+
+    public int executeUpdate(String sql, String columnNames[]) throws SQLException {
+        return stmt.executeUpdate(sql, columnNames);
+    }
+
+    public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
+        return stmt.execute(sql, autoGeneratedKeys);
+    }
+
+    public boolean execute(String sql, int columnIndexes[]) throws SQLException {
+        return stmt.execute(sql, columnIndexes);
+    }
+
+    public boolean execute(String sql, String columnNames[]) throws SQLException {
+        return stmt.execute(sql, columnNames);
+    }
+
+    public int getResultSetHoldability() throws SQLException {
+        return stmt.getResultSetHoldability();
+    }
+
+	public <T> T unwrap(Class<T> iface) throws SQLException {
+		return stmt.unwrap(iface);
+	}
+
+	public boolean isWrapperFor(Class<?> iface) throws SQLException {
+		return stmt.isWrapperFor(iface);
+	}
+
+	public boolean isClosed() throws SQLException {
+		return stmt.isClosed();
+	}
+
+	public void setPoolable(boolean poolable) throws SQLException {
+		stmt.setPoolable(poolable);
+	}
+
+	public boolean isPoolable() throws SQLException {
+		return stmt.isPoolable();
+	}
+}

pom.xml

@@ -8,6 +8,11 @@
 
 	<packaging>pom</packaging>
 
+	<modules>
+		<module>xmppserver</module>
+		<module>dbutil</module>
+	</modules>
+
 	<organization>
 		<name>Ignite Realtime</name>
 		<url>http://www.igniterealtime.org</url>
@@ -143,8 +148,8 @@
 				<artifactId>maven-compiler-plugin</artifactId>
 				<version>2.3.2</version>
 				<configuration>
-					<source>1.5</source>
-					<target>1.5</target>
+					<source>1.6</source>
+					<target>1.6</target>
 				</configuration>
 			</plugin>
 
@@ -168,7 +173,20 @@
 
 		</plugins>
 	</build>
-	<modules>
-		<module>xmppserver</module>
-	</modules>
+	
+	<dependencyManagement>
+		<dependencies>
+			<dependency>
+				<groupId>${project.groupId}</groupId>
+				<artifactId>xmppserver</artifactId>
+				<version>${project.version}</version>
+			</dependency>
+			<dependency>
+				<groupId>${project.groupId}</groupId>
+				<artifactId>dbutil</artifactId>
+				<version>${project.version}</version>
+			</dependency>
+		</dependencies>
+	</dependencyManagement>
+	
 </project>
\ No newline at end of file

xmppserver/pom.xml

@@ -14,16 +14,31 @@
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-compiler-plugin</artifactId>
 				<configuration>
-					<source>1.5</source>
-					<target>1.5</target>
 					<excludes>
 						<exclude>**/MINAStatCollector.java</exclude>
+						<exclude>**/org/jivesoftware/openfire/launcher/Launcher.java</exclude>
+						<exclude>**/org/jivesoftware/openfire/launcher/Uninstaller.java</exclude>						
 					</excludes>
 				</configuration>
 			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<configuration>
+					<excludes>
+						<exclude>**/Admin*.java</exclude>
+						<exclude>**/XMLProp*.java</exclude>
+					</excludes>
+				</configuration>
+			</plugin>			
 		</plugins>
 	</build>
 	<dependencies>
+		<dependency>
+			<groupId>${project.groupId}</groupId>
+			<artifactId>dbutil</artifactId>
+		</dependency>
+
 		<dependency>
 			<groupId>dom4j</groupId>
 			<artifactId>dom4j</artifactId>
@@ -65,6 +80,11 @@
 			<version>1.1.7</version>
 		</dependency>
 		<dependency>
+			<groupId>commons-httpclient</groupId>
+			<artifactId>commons-httpclient</artifactId>
+			<version>3.1</version>
+		</dependency>
+  		<dependency>
 			<groupId>org.bouncycastle</groupId>
 			<artifactId>bcprov-jdk16</artifactId>
 			<version>1.46</version>
@@ -104,12 +124,59 @@
 			<artifactId>jmdns</artifactId>
 			<version>3.4.1</version>
 		</dependency>
-
+		<dependency>
+			<groupId>rome</groupId>
+			<artifactId>rome</artifactId>
+			<version>0.9</version>
+		</dependency>
 		<dependency>
 			<groupId>rome</groupId>
 			<artifactId>rome-fetcher</artifactId>
 			<version>1.0</version>
 		</dependency>
-
+		<dependency>
+			<groupId>jstl</groupId>
+			<artifactId>jstl</artifactId>
+			<version>1.1.2</version>
+		</dependency>
+		<dependency>
+			<groupId>tomcat</groupId>
+			<artifactId>jasper-compiler</artifactId>
+			<version>5.5.15</version>
+		</dependency>
+		<dependency>
+			<groupId>tomcat</groupId>
+			<artifactId>jasper-runtime</artifactId>
+			<version>5.5.15</version>
+		</dependency>
+		<dependency>
+			<groupId>proxool</groupId>
+			<artifactId>proxool</artifactId>
+			<version>0.8.3</version>
+		</dependency>
+		<dependency>
+			<groupId>commons-lang</groupId>
+			<artifactId>commons-lang</artifactId>
+			<version>2.3</version>
+		</dependency>
+		<dependency>
+			<groupId>com.atlassian.shaj</groupId>
+			<artifactId>atlassian-shaj</artifactId>
+			<version>0.5</version>
+		</dependency>
+		
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.10</version>
+			<scope>test</scope>
+		</dependency>
 	</dependencies>
+
+	<repositories>
+		<repository>
+			<id>atlassian</id>
+			<url>https://maven.atlassian.com/content/groups/public/</url>
+		</repository>
+	</repositories>
 </project>
\ No newline at end of file