Application: gvSIG desktop

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>libAuthenticationService</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.jdt.core.javanature</nature>

	</natures>

</projectDescription>

package org.gvsig.authentication;

import java.util.Hashtable;

import org.gvsig.authentication.Authentication;

import org.gvsig.authentication.exception.InvalidUserException;

import junit.framework.Assert;

import junit.framework.TestCase;

public class TestAuthentication extends TestCase {

	protected void setUp() throws Exception {

		super.setUp();

	}

	protected void tearDown() throws Exception {

		super.tearDown();

	}

	public void testLogin(){

		Authentication authentication = new Authentication();

		Assert.assertFalse(authentication.login("lau","laura")>-1);

	}

	public void testGetConfig(){

		Authentication authentication = new Authentication();

		try{

			Hashtable ht = authentication.getConfig("laura","laura");

			String map = (String)ht.get("mapserver_file" );

			Hashtable config= (Hashtable)ht.get("gvsig_config");

			Assert.assertTrue(map.compareTo("users.map")==0);

			Assert.assertTrue(((String)(config.get("plugin2"))).compareTo("users.config")==0);

		}catch(InvalidUserException e)

		{

			e.printStackTrace(); 

		}

	}

	public void testGetMapFile(){

		Authentication authentication = new Authentication();

		try{

			String userMap = authentication.getMapFile("laura","laura");

			String adminMap = authentication.getMapFile("admin","admin");

			Assert.assertTrue(userMap.compareTo("users.map")==0);

			Assert.assertTrue(adminMap.compareTo("administratormap.map")==0);

		}catch(InvalidUserException e)

		{

			e.printStackTrace(); 

		}

	}

	public void testGvSigConfig(){

		Authentication authentication = new Authentication();

		try{

			Hashtable userConfig = authentication.getGvSigConfig("laura","laura");

			Hashtable adminConfig = authentication.getGvSigConfig("admin","admin");

			Assert.assertTrue(((String)(userConfig.get("plugin2"))).compareTo("users.config")==0);

			Assert.assertTrue(((String)(adminConfig.get("plugin1"))).compareTo("administrator.config")==0);

		}catch(InvalidUserException e)

		{

			e.printStackTrace(); 

		}

	}	

}

package org.gvsig.authentication.exception;

public class AuthenticationException extends Exception{

		private String as_message = null;

		public AuthenticationException() {

			super();

		}

		public AuthenticationException(String message) {

			super(message);

		}

		public AuthenticationException(String message, Throwable cause) {

			super(message, cause);

		}

		public AuthenticationException(Throwable cause) {

			super(cause);

		}

		public String getAuthenticationServiceExceptionMessage()

		{

			if (as_message == null)

				return "";

			else

				return as_message;

		}

		public void setAuthenticationServiceExceptionMessage(String mes)

		{

			as_message = mes;

		}

	}

package org.gvsig.authentication.exception;

public class DBConnectionException extends AuthenticationException {	

		public DBConnectionException() {

			super();

		}

		public DBConnectionException(String message) {

			super(message);

		}

		public DBConnectionException(String message, Throwable cause) {

			super(message, cause);

		}

		public DBConnectionException(Throwable cause) {

			super(cause);

		}

	}

package org.gvsig.authentication.exception;

/**

 * Exeption to be thrown when an invalid user/password is given

 * @author laura

 *

 */

public class InvalidUserException extends AuthenticationException {	

		public InvalidUserException() {

			super();

		}

		public InvalidUserException(String message) {

			super(message);

		}

		public InvalidUserException(String message, Throwable cause) {

			super(message, cause);

		}

		public InvalidUserException(Throwable cause) {

			super(cause);

		}

	}

package org.gvsig.authentication;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.Hashtable;

import java.util.Vector;

import org.gvsig.authentication.db.DatabaseHandler;

import org.gvsig.authentication.db.QueryBuilder;

import org.gvsig.authentication.exception.DBConnectionException;

import org.gvsig.authentication.exception.InvalidUserException;

import org.gvsig.authentication.utils.LogManager;

import org.gvsig.authentication.utils.Logger;

/**

 *  Provides the functionality to process the authentication and the authorization in the DB. 

 * @author laura

 */

public class Authentication {

	private DatabaseHandler dbHandler;

	private Logger m_log = LogManager.getLogManager().getLogger(Authentication.class.getName());

	public Authentication()	{

		dbHandler = new DatabaseHandler(); 

	}

	/**

     * Tries to log in the db with the info sent by the user.

     * @param userName

     * @param password

     * @return

     */

    public int login(String userName, String password)

    {

    	Statement stm = null;

		ResultSet rs = null;

		String query = null;

		int userId = -1;	

    	try {

    		dbHandler.initConnection("default");

			query = QueryBuilder.getLoginQuery(userName, password);

			stm = dbHandler.getConnection().createStatement();

			rs = stm.executeQuery(query);

			if (rs.first()){

				userId = rs.getInt(QueryBuilder.USER_ID);

			}

			return userId;

    	} catch (SQLException e) {

    		m_log.error("DatabaseHandler.login()." ,e);

			e.printStackTrace();

			return userId;

		} catch (DBConnectionException e) {

			m_log.error("DatabaseHandler.login()." ,e);

			e.printStackTrace();

			return userId;

		}finally{

			if (dbHandler.getConnection() != null){

				try{

					stm.close();

					rs.close(); 

					dbHandler.releaseConnection("default");

				}catch(Exception fin){

					m_log.error("",fin);

					fin.printStackTrace(); 

					return userId;

				}

			}

		}

    }

    private Vector getRoles(String userId)

    {

    	Statement stm = null;

		ResultSet rs = null;

		String query = null;	

    	int roleId = -1;    	

    	Vector roles = new Vector();    	

		query = QueryBuilder.getUserRolesIds(userId);

		try {

			stm = dbHandler.getConnection().createStatement();

			rs = stm.executeQuery(query);			

			// rs contains the roles ids to which this user belongs

			// at this moment we are going to simplify this to one role per user			

			if (rs.first())

			{

				do{

					roleId = rs.getInt(QueryBuilder.USER_ROLES_ROLES_ID_COL);

					if(roleId > -1)

					{

						roles.add(""+roleId);

					}

				}while(rs.next());

			}

		} catch (SQLException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}finally{

			if (dbHandler.getConnection() != null){

				try{

					rs.close();

					stm.close();

				}catch(Exception fin){

					m_log.error("",fin);

					fin.printStackTrace(); 

					return null;

				}

			}

		}

		return roles;

    }

    /**

     * gets the gvSIG config file

     * @param userName

     * @param password

     * @return a String with the gvSIG confog file

     * @throws InvalidUserException

     */

    public Hashtable getGvSigConfig(String userName, String password)

    		throws InvalidUserException 

    {

    	int userId = login(userName, password);

    	if ( userId > -1){

    		return getGvSigConfig(userId);

    	}

    	else{

    		throw new InvalidUserException("Authentication ERROR: Invalid user trying to get gvSIG file");

    	}

    }

	/**

     * Gets the gvSig configuration file associated to the user role.

     * First checks if the user/password is correct.

     * @param userName

     * @param password

     * @return

     */

    private Hashtable getGvSigConfig(int userId)

    {

    	Statement stm = null;

		ResultSet rs = null;

		String query = null;	

    	Vector roles = new Vector();

    	Hashtable ht = new Hashtable();

    	try {

    		dbHandler.initConnection("default");

    		roles = getRoles(String.valueOf(userId));

			if (roles.size() > 0 )//if (roleId > -1)

			{

				query = QueryBuilder.getGvSigConfigDataQuery(roles);

				stm = dbHandler.getConnection().createStatement();

				rs = stm.executeQuery(query);				

				if (rs.first())

				{

					do{

						ht.put(rs.getString(QueryBuilder.GRANTS_NAME_COL),rs.getString(QueryBuilder.GRANTS_DATA_COL));

					}while (rs.next());

				}						

			}

			return ht;

    	} catch (SQLException e) {

    		m_log.error("DatabaseHandler.getGvSigConfig()." ,e);

			e.printStackTrace();

			return null;

		} catch (DBConnectionException e) {

			m_log.error("DatabaseHandler.getGvSigConfig()." ,e);

			e.printStackTrace();

			return null;

		}finally{

			if (dbHandler.getConnection() != null){

				try{

					rs.close();

					stm.close();

					dbHandler.releaseConnection("default");

				}catch(Exception fin){

					m_log.error("",fin);

					fin.printStackTrace(); 

					return null;

				}

			}

		}

    }    

    /**

     * Returns mapserver map file for this user

     * @param userName

     * @param password

     * @return

     * @throws InvalidUserException

     */

    public String getMapFile(String userName, String password)

    		throws InvalidUserException

    {

    	int userId = login(userName, password);

    	if (userId > -1){

    		return getMapFile(String.valueOf(userId));

    	}

    	else{

    		throw new InvalidUserException("Authentication ERROR: Invalid user trying to get gvSIG file");

    	}

    }    

	/**

     * Gets the mapserver map file associated to the user role.

     * First checks if the user/password is correct.

     * @param userName

     * @param password

     * @return

     */

    private String getMapFile(String userId)

    {

    	Statement stm = null;

		ResultSet rs = null;

		String query = null;	

    	Vector roles = new Vector();

    	try {

    		dbHandler.initConnection("default");

    		roles = getRoles(userId);

			if (roles.size() > 0 )//if (roleId > -1)

			{

				query = QueryBuilder.getMapConfigDataQuery(roles);

				stm = dbHandler.getConnection().createStatement();

				rs = stm.executeQuery(query);

//				esta ordenado por prioridad descendente, el ultimo es el de prioridad mas alta				

				if (rs.last())

				{					

					return rs.getString(QueryBuilder.GRANTS_DATA_COL);

				}					

			}

			return "";

    	} catch (SQLException e) {

    		m_log.error("DatabaseHandler.getGvSigConfig()." ,e);

			e.printStackTrace();

			return "";

		} catch (DBConnectionException e) {

			m_log.error("DatabaseHandler.getGvSigConfig()." ,e);

			e.printStackTrace();

			return "";

		}finally{

			if (dbHandler.getConnection() != null){

				try{

					dbHandler.releaseConnection("default");

					rs.close();

					stm.close();

				}catch(Exception fin){

					m_log.error("",fin);

					fin.printStackTrace(); 

					return "";

				}

			}

		}

    }     

	/**

     * Gets all the configuration associated to this user/password

     * returns the gvSIG config file and the mapserver map file 

     * First checks if the user/password is correct.

     * @param userName

     * @param password

     * @return

     */

    public Hashtable getConfig(String userName, String password)

    		throws InvalidUserException

    {

    	Hashtable ht = new Hashtable();

    	Hashtable configTable = new Hashtable();

    	String query;

    	int userId;

       	Statement stm = null;

		ResultSet rs = null;

		String mapserverFile = "";

		String hojasmapFile = "";

		String wms = "";

		Vector roles = new Vector();

    	try {

    		userId = login(userName, password);

			if(userId > -1){

				dbHandler.initConnection("default"); 

				roles = getRoles(String.valueOf(userId));

				if(roles.size() > 0 ) //if (roleId > -1)

				{

					query = QueryBuilder.getMapConfigDataQuery(roles);					

					stm = dbHandler.getConnection().createStatement(); 

					rs = stm.executeQuery(query);

					//el ultimo es del role de este usuario con mayor prioridad

					if (rs.last())

					{

						mapserverFile = rs.getString(QueryBuilder.GRANTS_DATA_COL);

					}	

					rs.close();

					rs = null;

					query = QueryBuilder.getWMSQuery(roles);		

					m_log.debug("getWMSQuery(roles): " + query);

					stm = dbHandler.getConnection().createStatement(); 

					rs = stm.executeQuery(query);

					//el ultimo es del role de este usuario con mayor prioridad

					if (rs.last())

					{

						wms = rs.getString(QueryBuilder.GRANTS_DATA_COL);

					}	

					rs.close();

					rs = null;

					query = QueryBuilder.getHojasMapDataQuery(roles);		

					m_log.debug("getHojasMapfile(roles): " + query);

					stm = dbHandler.getConnection().createStatement(); 

					rs = stm.executeQuery(query);

					if (rs.last())

					{

						hojasmapFile  = rs.getString(QueryBuilder.GRANTS_DATA_COL);

					}	

					rs.close();

					rs = null;

					query = QueryBuilder.getGvSigConfigDataQuery(roles);

					m_log.debug("getGvSigConfigDataQuery(roles): " + query);

					rs = stm.executeQuery(query);				

					if (rs.first())

					{

						do{

							configTable.put(rs.getString(QueryBuilder.GRANTS_NAME_COL),rs.getString(QueryBuilder.GRANTS_DATA_COL));

						}while (rs.next());

					}	

				}								  				    			

				ht.put("gvsig_config", configTable);

				ht.put("mapserver_file", mapserverFile);

				ht.put("wms", wms);

				ht.put("hojas_mapfile", hojasmapFile);

			}    		

    		else{

    			throw new InvalidUserException ("Authentication Error: Invalid user."); 			

    		}

    		return ht;

       	} catch (SQLException e) {

    		m_log.error("Authentication.getConfig()." ,e);

			e.printStackTrace();

			return null;

		} catch (DBConnectionException e) {

			m_log.error("Authentication.getConfig()." ,e);

			e.printStackTrace();

			return null;

		} catch (Exception e) {

			m_log.error("Authentication.getConfig()." ,e);

			e.printStackTrace();

			return null;				

		}finally{

			if (dbHandler.getConnection() != null){

				try{

					dbHandler.releaseConnection("default");

					rs.close();

					stm.close();

				}catch(Exception fin){

					m_log.error("",fin);

					fin.printStackTrace(); 

					return null;

				}

			}

		}    		

    }     

}

package org.gvsig.authentication.utils;

import java.util.HashMap;

import java.util.Properties;

import org.apache.log4j.PropertyConfigurator;

/**

 * @author        Laura diaz

 * @version       1.1

 */

public class LogManager 

{

  private static Object s_lock;

  private static LogManager s_logManager;

  private static HashMap s_loggers;

  static

  {

    s_lock = new Object();

  }

  /**

  * Constructor

  *

  * Private so clients can not instanciate this directly

  */

  private LogManager()

  {

    try

    {

      s_loggers = new HashMap();

      Properties properties = PropertyManager.getProperties(PropertyManager.LOGGER_PROPERTIES);

      PropertyConfigurator.configure(properties);

    }

    catch(Exception ex)

    {

      System.out.println("Could not load properties " + PropertyManager.LOGGER_PROPERTIES);

    }

  }

  /**

  * Gets the instance of the LogManager 

  *

  *@return LogManager

  */

  public static LogManager getLogManager()

  {

    if (s_logManager == null)

    {

      synchronized (s_lock)

      {

        if (s_logManager == null)

        {

          s_logManager = new LogManager();

        }

      }

    }

    return s_logManager;

  }

  /**

  * Gets the appropriate Logger

  * 

  *@param String - name, usually the name of the class that calls this

  *@return Logger

  */

  public Logger getLogger(String name)

  {

    if (s_loggers.containsKey(name))

    {

      return (Logger)s_loggers.get(name);

    }

    Logger logger = new Logger(name);

    s_loggers.put(name, logger);

    return logger;

  }

}

package org.gvsig.authentication.utils;

import org.apache.log4j.Category;

import java.io.CharArrayWriter;

import java.io.PrintWriter;

import java.io.IOException;

import java.util.Properties;

/**

 * @author        Laura Diaz

 * @version       1.0

 */

public class Logger 

{

	private static final String DEBUG_MAXSIZE_PROPERTY = "log4j.debug.maxsize";

	private static final String INFO_MAXSIZE_PROPERTY = "log4j.info.maxsize";

	private static Category m_category;

	private int m_maxSizeDebugMsg;

	private int m_maxSizeInfoMsg;  

	/**

	 * Constructor

	 *

	 * Protected so, only classes in the same package or descendants can instanciate this

	 */

	protected Logger(String name)

	{

		m_category = Category.getInstance(name);

		m_maxSizeDebugMsg = readMaxSizeProperty(DEBUG_MAXSIZE_PROPERTY, 0);

		m_maxSizeInfoMsg = readMaxSizeProperty(INFO_MAXSIZE_PROPERTY, 0);

	}

	/**

	 * Adds a debug message

	 */

	public void debug(String msg)

	{

		/*

		 * Write message to log. If enabled, if the message is too long, it

		 * will be truncated.

		 */

		if (m_maxSizeDebugMsg <= 0)

		{

		  m_category.debug(msg + "\n");

		}

		else {

		  if (msg.length() <= m_maxSizeDebugMsg)

		  {

			m_category.debug(msg + "\n");

		  }

		  else

		  {

			StringBuffer sb = new StringBuffer(msg.substring(0, m_maxSizeDebugMsg));

			sb.append(" [TRUNCATED BY LOGGER SEE property \"");

			sb.append(DEBUG_MAXSIZE_PROPERTY);

			sb.append("\"]\n");

			m_category.debug(sb.toString());

		  }

		}

	}

	/**

	 * Adds an info message

	 */

	public void info(String msg)

	{

		/*

		 * Write message to log. If enabled, if the message is too long, it

		 * will be truncated.

		 */

		if (m_maxSizeInfoMsg <= 0)

		{

		  m_category.info(msg + "\n");

		}

		else {

		  if (msg.length() <= m_maxSizeInfoMsg)

		  {

			m_category.info(msg + "\n");

		  }

		  else

		  {

			StringBuffer sb = new StringBuffer(msg.substring(0, m_maxSizeInfoMsg));

			sb.append(" [TRUNCATED BY LOGGER SEE property \"");

			sb.append(INFO_MAXSIZE_PROPERTY);

			sb.append("\"]\n");

			m_category.info(sb.toString());

		  }

		}

	}

	/**

	 * Adds an warning message

	 */

	public void warning(String msg)

	{

		m_category.warn(msg + "\n");

	}

	/**

	 * Adds an error message

	 */

	public void error(String msg)

	{

		m_category.fatal(msg + "\n");

	}

	/**

	 * Writes a message to the error log. This message includes the

	 * detail message of the given exception as well as the

	 * exception's stack trace.

	 * 

	 * @param  descr  description of the error.

	 * @param  e      exception that was caught. 

	 */

	public void error(String descr, Exception e)

	{	

		m_category.fatal(descr + ": detail message = \"" + e.getMessage()

			+ "\", trace =\n" + Logger.stackTraceToString(e));

	}

	/**

	 * Converts the stack trace of the given exception to a string.

	 */  

	public static String stackTraceToString(Exception e)

	{

	  try

	  {

		CharArrayWriter writer = new CharArrayWriter();

		e.printStackTrace(new PrintWriter(writer));

		return writer.toString();

	  }

	  catch(Exception e2)

	  {

		return " [failed to convert stacktrace to string] ";

	  }

	}

	/**

	 * Reads the named property from the logger properties file and returns

	 * it. If the property is missing or if its value is invalid, the value

	 * of <code>defValue</code> is returned.

	 */	

	private int readMaxSizeProperty(String propName, int defValue)

	{

		try

		{

			Properties props = PropertyManager.getProperties(

								PropertyManager.LOGGER_PROPERTIES);

			if (props == null)

			{

				System.err.println("[Logger] Failed to read property \""

					+ propName + "\": cannot get properties of "

					+ PropertyManager.LOGGER_PROPERTIES);

				return defValue;

			}

			int n = defValue;

			String s = props.getProperty(propName);

			if (s != null && s.length() != 0)

			{

				try

				{

					int k  = Integer.parseInt(s);

					if (k > 0)

					{

						n = k;

					}

				}

				catch(NumberFormatException e)

				{

					System.err.println("[Logger] invalid value for property \""

						+ propName + "\": not an integer: " + s

						+ "---ignoring property");

					return defValue;

				}

			}

			return n;

		}

		catch(IOException e)

		{

			System.err.println("[Logger] Failed to read property \"" + propName

				+ "\": I/O error: " + e.getMessage() + "---ignoring property");

			return defValue;

		}

	}

}

package org.gvsig.authentication.utils;

import java.util.Properties;

import java.util.Hashtable;

import java.io.InputStream;

import java.io.IOException;

/**

 * Description: Loads the configuration files

 *

 * @author  Laura Diaz

 * @version 1.0 

 */

public class PropertyManager

{

 public final static String LOGGER_PROPERTIES = "org/gvsig/authentication/conf/logger.properties";

 public final static String DB_PROPERTIES = "org/gvsig/authentication/conf/connection.properties";

 //The property file names to load

 private final static String[] s_propertyFileNames = new String[]{	LOGGER_PROPERTIES

 																	,DB_PROPERTIES};

 //Hashtable containing all properties objects that are loaded

 private static Hashtable s_propertyFiles = null;

 /**

 * Gets a properties object

 * If the the property files are not yet loaded, then loads them first

 *

 * @param propertyFileName, String

 * @return Properties

 * @throws java.io.IOException

 */

 public static Properties getProperties(String propertyFileName) throws IOException

 {

   if (s_propertyFiles == null)

   {

     loadProperties();

   }

   return (Properties)s_propertyFiles.get(propertyFileName);

 }

 //Loads the property files

 private static synchronized void loadProperties() throws IOException

 {

   s_propertyFiles = new Hashtable(s_propertyFileNames.length);

   ClassLoader loader = PropertyManager.class.getClassLoader();

   for (int i = 0; i < s_propertyFileNames.length; i++)

   {

     try

     {

       InputStream input = loader.getResourceAsStream(s_propertyFileNames[i]);

       Properties props = new Properties();

       props.load(input);

       s_propertyFiles.put(s_propertyFileNames[i], props);

     }

     catch(Exception e)

     {

     	System.err.println("\n[PropertyManager] ERROR - Failed to read properties file \""

                          + s_propertyFileNames[i] + "\": "

                          + e.getMessage());       

     }

   }

 }

}

# Connection PROPERTY FILE

# Set here if you want to make use of the Pool for getting a connection

# If you want a connectin from the pool set in "connection_name" 

# the name of the connection in the Pool that you want to use 

usepool=true

#connection_name=authenConn

# ----------- NORMAL CONNECTION ----------

# In case the connection Pool is not used, here we write the properties

# for a normal connection, URL, passwd and user

# The URL: jdbc_DB:driver_types:@IP_number:DB_port_number:SID

#jdbc:postgresql://host:port/database 

url=jdbc:postgresql://192.168.0.217:5432/costas

password=ldiaz

user=ldiaz

# ------------- COMMON -------------

# Drivers used for Java to connect to the DB, this property is for the POOL

# and for the normal connection

drivers=org.postgresql.Driver

# ---------------- POOL ------------------

# Here you write all the connections in the Pool

# Set here all their properties.

# NOTE : The Pool manager will create as many pools as

#       pool-configuration blocks are defined in here (pool names)

default.url=jdbc:postgresql://192.168.0.217:5432/costas

default.password=ldiaz

default.user=ldiaz

default.maxconns=200

default.initconns=10

default.logintimeout=5

authenConn.url=jdbc:postgresql://192.168.0.217:5432/costas

authenConn.password=ldiaz

authenConn.user=ldiaz

authenConn.maxconns=200

authenConn.initconns=10

authenConn.logintimeout=5

fran.url=jdbc:postgresql://fjp2/latin1

fran.password=aquilina

fran.user=postgres

fran.maxconns=200

fran.initconns=10

fran.logintimeout=5

# LOGGER PROPERTIES

## limit is ignored if its value is empty or if its value is set to zero.

## Note: this property only affects info messages.

#log4j.info.maxsize=

## Set root category priority to DEBUG and its only appender to stdout.

## on a windows machine:

#log4j.rootCategory=DEBUG, stdout

# on the freya:

log4j.rootCategory=DEBUG, file

#log4j.rootCategory=FATAL

## stdout is set to be a ConsoleAppender which outputs to System.out.

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%d [%t] %-5p %c - %m%n

log4j.appender.file=org.apache.log4j.RollingFileAppender

log4j.appender.file.File=C:\\projects\\gvsig\\AuthenticationService.log

log4j.appender.file.MaxBackupIndex=1

log4j.appender.file.MaxFileSize=100KB

log4j.appender.file.layout=org.apache.log4j.PatternLayout

log4j.appender.file.layout.ConversionPattern=%d [%t] %-5p %c - %m%n

##

## Package Logging 

##

## Each package can have its own appender

##

## Priorities are as follows :

##

## 1. FATAL

## 2. ERROR

## 3. WARN

## 4. INFO

## 5. DEBUG

##

## If a package has a priority of DEBUG, this means all

## messages will be shown in the log. If the priority is

## INFO, then all messages with a minimum priory of INFO will

## be shown i.e. INFO, WARN, ERROR and FATAL

##

## For minimum log output, set the priority to FATAL

##

#log4j.category.nl.rivm.rrgs.log.NogEenTester=DEBUG, R1

#log4j.appender.R1=org.apache.log4j.RollingFileAppender

#log4j.appender.R1.File=d:\\Test1.log

#log4j.appender.R1.MaxBackupIndex=1

#log4j.appender.R1.MaxFileSize=100KB

#log4j.appender.R1.layout=org.apache.log4j.PatternLayout

#log4j.appender.R1.layout.ConversionPattern=%d %p %t %c - %m%n

#log4j.category.nl.rivm.rrgs.log.Tester=DEBUG, R

#log4j.appender.R=org.apache.log4j.RollingFileAppender

#log4j.appender.R.File=d:\\Test.log

#log4j.appender.R.MaxBackupIndex=1

#log4j.appender.R.MaxFileSize=100KB

#log4j.appender.R.layout=org.apache.log4j.PatternLayout

#log4j.appender.R.layout.ConversionPattern=%d %p %t %c - %m%n

package org.gvsig.authentication.db;

import java.sql.Connection;

import org.gvsig.authentication.exception.DBConnectionException;

import org.gvsig.authentication.utils.LogManager;

import org.gvsig.authentication.utils.Logger;

/**

 * This class will hold all the methods to perform actions in the DB

 * like initialize/release a connection, log in a user...

 * 

 * NOTE:

 *  As first approach we'll open a connection/action performed

 *  in the database, maybe we have to change it to open a connection

 *  per DatabaseHandler life cicle ???

 *  

 * @author laura

 *

 */

public class DatabaseHandler {

	private Connection m_connection;

	private ConnectionManager m_connectionManager;	

	private Logger m_log;

	public DatabaseHandler()

	{

		m_log = LogManager.getLogManager().getLogger(getClass().getName());

		m_connectionManager = new ConnectionManager(); 

		m_log.debug("DatabaseHandler initialize.");

	}	

	public Connection getConnection()

	{

		return m_connection;

	}

   public void initConnection(String connectionName) throws DBConnectionException

    {

		if (m_connection == null)

		{

			m_connection = m_connectionManager.getConnection(connectionName);				

		}		

    }

	public void releaseConnection(String connectionName) throws DBConnectionException

	{	

		if (m_connection != null)

		{

			m_connectionManager.freeConnection(m_connection,connectionName);

			m_connection = null;

		}

	} 	

}

package org.gvsig.authentication.db;

import java.sql.*;

import java.util.*;

import org.gvsig.authentication.utils.LogManager;

import org.gvsig.authentication.utils.Logger;

import org.gvsig.authentication.utils.PropertyManager;

public class PoolManager

{

   static private PoolManager m_instance;

   static private int m_clients;

   private Vector m_drivers = new Vector();

   /*

    * The connection pools. Once this map is initialized (during the construction of the

    * PoolManager) it will be used in read-only mode (i.e., it will never be modified)

    * until the PoolManager is released.

    */

   private HashMap m_pools = new HashMap();

   private Logger m_log = LogManager.getLogManager().getLogger(PoolManager.class.getName());  

   private PoolManager()

   {

      init();

   }

   static synchronized public PoolManager getInstance()

   {

      if (m_instance == null)

      {

         m_instance = new PoolManager();

      }

      m_clients++;

      return m_instance;

   }

   private void init()

   {

      Properties dbProps = new Properties();

      try

      {

        dbProps = PropertyManager.getProperties(PropertyManager.DB_PROPERTIES);

      }

      catch (Exception e)

      {

        m_log.error("Can't read the properties file. "

        	+ "Make sure " + PropertyManager.DB_PROPERTIES

            + " is in the CLASSPATH");

         return;

      }      

      loadDrivers(dbProps);

      createPools(dbProps);

   }

   private void loadDrivers(Properties props)

   {

      String driverClasses = props.getProperty("drivers");

      StringTokenizer st = new StringTokenizer(driverClasses);

      while (st.hasMoreElements())

      {

         String driverClassName = st.nextToken().trim();

         try

         {

            Driver driver = (Driver)

               Class.forName(driverClassName).newInstance();

            DriverManager.registerDriver(driver);

            m_drivers.addElement(driver);

            m_log.debug("Registered JDBC driver \"" + driverClassName + "\"");              

         }

         catch (Exception e)

         {

            logException("Can't register JDBC driver \""

              + driverClassName + "\"", e);

         }

      }

   }

   private void createPools(Properties props)

   {

      Enumeration propNames = props.propertyNames();

      while (propNames.hasMoreElements())

      {

         String name = (String) propNames.nextElement();

         if (name.endsWith(".url"))

         {

            String poolName = name.substring(0, name.lastIndexOf("."));

            String url = props.getProperty(poolName + ".url");

            if (url == null)

            {

               m_log.debug("No URL specified for \"" + poolName

                 + "\" -- skipped");

               continue;

            }

            String user = props.getProperty(poolName + ".user");

            String password = props.getProperty(poolName + ".password");

            String maxConns = props.getProperty(poolName +

               ".maxconns", "0");

            int max;

            try

            {

               max = Integer.parseInt(maxConns);

            }

            catch (NumberFormatException e)

            {

               m_log.error("Invalid maxconns value \"" + maxConns

                 + "\" for \"" + poolName + "\": not a valid number");

               max = 0;

            }

            String initConns = props.getProperty(poolName +

                              ".initconns", "0");

            int init;

            try

            {

               init = Integer.parseInt(initConns);

            }

            catch (NumberFormatException e)

            {

               m_log.error("Invalid initconns value \"" + initConns

                 + " for \"" + poolName

                 + "\": not a valid number -- setting value to 0");

               init = 0;

            }

            String loginTimeOut = props.getProperty(poolName +

               ".logintimeout", "5");

            int timeOut;

            try

            {

               timeOut = Integer.parseInt(loginTimeOut);

            }

            catch (NumberFormatException e)

            {

               m_log.error("Invalid logintimeout value \""

                 + loginTimeOut + "\" for \"" + poolName

                 + "\": not a valid number -- setting value to 5");

               timeOut = 5;

            }

/*

            String logLevelProp = props.getProperty(poolName +

                           ".loglevel", String.valueOf(LogWriter.ERROR));

            int logLevel = LogWriter.INFO;

            if (logLevelProp.equalsIgnoreCase("none"))

            {

               logLevel = LogWriter.NONE;

            }

            else if (logLevelProp.equalsIgnoreCase("error"))

            {

               logLevel = LogWriter.ERROR;

            }

            else if (logLevelProp.equalsIgnoreCase("debug"))

            {

               logLevel = LogWriter.DEBUG;

            }

*/            

            ConnectionPool pool =

                           new ConnectionPool(poolName, url, user, password,

                                            max, init, timeOut);

            m_pools.put(poolName, pool);

         }

      }

   }

   /** returns a connection from the pool named: 'default'*/

   public Connection getConnection()

   {

      Connection conn = null;

      ConnectionPool pool = (ConnectionPool) m_pools.get("default");

      if (pool != null)

      {

         try

         {

            conn = pool.getConnection();

         }

         catch (SQLException e)

         {

            logException("Failed to get pool connection", e);

         }

      }

      return conn;

   }

   public Connection getConnection(String name)

   {

      ConnectionPool pool = (ConnectionPool) m_pools.get(name);

      if (pool != null)

      {

         try

         {

            return pool.getConnection();

         }

         catch (SQLException e)

         {

            logException("Failed to get pool connection \""

              + name + "\"", e);

         }

      }

      return null;

   }

   /** Free a connection to the default database as specified in the