propertiesmanager.java

OPIAM stands for Open Identity and Access Management. This Suite will provide modules for user & rig

/*
 * OPIAM Suite
 *
 * Distributable under LGPL license.
 * See terms of license at gnu.org.
 */

package opiam.admin.faare;

import opiam.admin.faare.config.PersistenceConfig;
import opiam.admin.faare.config.ProfilesConfig;
import opiam.admin.faare.config.javabeans.JBProfiles;
import opiam.admin.faare.config.javabeans.PersistenceDescriptionMap;
import opiam.admin.faare.exception.ConfigurationException;
import opiam.admin.faare.exception.PersistenceException;
import opiam.admin.faare.exception.ServiceException;
import opiam.admin.faare.service.services.StandardService;

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import java.lang.reflect.Method;

import java.util.Calendar;
import java.util.Enumeration;
import java.util.MissingResourceException;
import java.util.Properties;
import java.util.ResourceBundle;


/**
 * This class is the Product main entry point.
 * It initializes Log4J, loads all mandatory configuration files,
 * and initializes services registered in
 * service.properties file.
 *
 */
public final class PropertiesManager
{
    /** Log4j properties file. */
    public static final String LOG4J_PROPS_FILE = "/config/core/logger_config.properties";

    /** Registered services properties file.  */
    public static final String SERVICE_PROPS_FILE = "/config/service/service.properties";

    /** LDAP => Object mapping file. */
    public static final String FAARE_MAPPING_FILE = "/config/core/faare_mapping.xml";

    /** Resources and profiles configuration file. */
    public static final String PROFILES_XML_FILE = "/config/core/profiles_config.xml";

    /** Message properties file. */
    public static final String MESSAGE_RESOURCE_FILE = "config.core.faare_messages";

    /** PropertiesManager instance. */
    private static PropertiesManager _instance = null;

    /** Current Log4J instance. */
    private static Logger _logger = null;

    /** List of registered services. */
    private Properties serviceProperties = new Properties();

    /** Configured messages. */
    private ResourceBundle msgResourceBundle;

    /** Configured profiles. */
    private JBProfiles jbProfiles;

    /** Configured mapping table. */
    private PersistenceDescriptionMap persistenceDescriptionMap;

    /**
     * Creates a new PropertiesManager object.
     * Initializes Log4J, 
     * loads messages file,
     * loads mapping configuration.
     * @param directory Configuration directory or null if it is in the CLASSPATH
     */
    private PropertiesManager(String directory)
    {
        try
        {
            try
            {
                //Configuration de Log4J
                Properties log4jProps = new Properties();

                if (directory == null)
                {
                    log4jProps.load(this.getClass().getResourceAsStream(LOG4J_PROPS_FILE));
                }
                else
                {
                    File f = new File(directory + LOG4J_PROPS_FILE);
                    log4jProps.load(new FileInputStream(f));
                }

                String useThisConfiguratorStr = log4jProps.getProperty(
                        "useThisConfigurator");

                if ((useThisConfiguratorStr == null) ||
                        (useThisConfiguratorStr.compareToIgnoreCase("true") == 1))
                {
                    PropertyConfigurator.configure(log4jProps);
                }
                else
                {
                    System.out.println(
                        ".. PropertiesManager.initialize() log4j deja configure");
                }

                _logger = Logger.getLogger(PropertiesManager.class.getName());
                _logger.info(".. PropertiesManager.initialize() <start>");
                _logger.info(LOG4J_PROPS_FILE + " succesfully loaded");
            }
            catch (Exception ex)
            {
                System.out.println("***** " + ex.getMessage());
            }

            /*Chargement du ResourceBundle*/
            try
            {
                setMsgResourceBundle(ResourceBundle.getBundle(
                        MESSAGE_RESOURCE_FILE));
                MessageUtil.initialize(getMsgResourceBundle());
                _logger.info(MESSAGE_RESOURCE_FILE + " succesfully loaded");
            }
            catch (MissingResourceException mre)
            {
                _logger.error(
                    ".. PropertiesManager.initialize() <resources not found>");
            }

            /* chargement du fichier de mapping faare_mapping.xml avec Apache digester */
            try
            {
                if (directory == null)
                {
                    persistenceDescriptionMap = PersistenceConfig.getInstance()
                                                  .readConfig(this.getClass()
                                                  .getResourceAsStream(FAARE_MAPPING_FILE));
                }
                else
                {
                    File f = new File(directory + FAARE_MAPPING_FILE);
                    persistenceDescriptionMap = PersistenceConfig.getInstance()
                                                                 .readConfig(new FileInputStream(
                                f));
                }
            }
            catch (RuntimeException e)
            {
                throw new PersistenceException(MessageUtil.formatMessage(
                        "MSG_MAPPING_ERROR", e.getMessage()), e);
            }

            _logger.info(".. PropertiesManager.initialize() <end>");
        }
        catch (Exception ex)
        {
            if (_logger.isDebugEnabled())
            {
                _logger.debug("Trace", ex);
            }

            _logger.error("PropertiesManager construction failed");
            throw new RuntimeException("PropertiesManager construction failed");
        }
    }

    /**
     * Allows to reinitialize the Product configuration files.
     *
     * @param repertory Configuration directory.
     */
    public static void reload(String repertory)
    {
        _instance = null;
        getInstance(repertory);
    }

    /**
     * Initializes all registered services,
     * loads resources and profiles configuration,
     * initializes standard service.
     * @param directory Configuration directory or null
     *
     * @throws ServiceException if an error occurs while initialising a service.
     */
    private void initServiceContextProperties(String directory)
        throws ServiceException
    {
        try
        {
            //  chargement du fichier service.properties
            if (directory == null)
            {
                getServiceProperties().load(this.getClass().getResourceAsStream(SERVICE_PROPS_FILE));
            }
            else
            {
                File f = new File(directory + SERVICE_PROPS_FILE);
                getServiceProperties().load(new FileInputStream(f));
            }

            Enumeration enum = getServiceProperties().elements();
            String serviceClassName = null;
            Class cls = null;
            Method method = null;
            Class[] parametersClasses = new Class[1];
            Object[] parametersTab = new Object[1];

            while (enum.hasMoreElements())
            {
                serviceClassName = (String) enum.nextElement();
                _logger.debug("Appel pour classe : " + serviceClassName);
                cls = Class.forName(serviceClassName);

                Class[] classTab = {String.class};
                method = cls.getMethod("initialize", classTab);
                _logger.debug("Methode : " + method);

                Object[] obj = {directory};
                method.invoke(null, obj);
            }

            /*Chargement de l'objet JBProfiles