DBManager.java

/*
 * GovWay - A customizable API Gateway 
 * https://govway.org
 * 
 * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3, as published by
 * the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */


package org.openspcoop2.web.ctrlstat.core;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Enumeration;

import javax.naming.InitialContext;
import javax.sql.DataSource;

import org.openspcoop2.utils.jdbc.JDBCUtilities;
import org.slf4j.Logger;

/**
 * Contiene la gestione delle connessioni ad un Database. Il nome della risorsa
 * JNDI da cui e' possibile attingere connessioni verso il Database, viene
 * selezionato attraverso le impostazioni lette dal file
 * 'console.datasource.properties'.
 * 
 * @author Andrea Poli (apoli@link.it)
 * @author Stefano Corallo (corallo@link.it)
 * @author Sandra Giangrandi (sandra@link.it)
 * @author $Author$
 * @version $Rev$, $Date$
 * 
 */
public class DBManager {

    private static Logger checkLogger = null;
    private static boolean checkIsClosed = true;
    private static boolean checkAutocommit = true;
    public static boolean isCheckIsClosed() {
        return checkIsClosed;
    }
    public static void setCheckIsClosed(boolean checkIsClosed) {
        DBManager.checkIsClosed = checkIsClosed;
    }
    public static boolean isCheckAutocommit() {
        return checkAutocommit;
    }
    public static void setCheckAutocommit(boolean checkAutocommit) {
        DBManager.checkAutocommit = checkAutocommit;
    }
    public static Logger getCheckLogger() {
        return checkLogger;
    }
    public static void setCheckLogger(Logger checkLogger) {
        DBManager.checkLogger = checkLogger;
    }
    
    
    /** Logger utilizzato per debug. */
    private static Logger log = null;

    /** DBManager */
    private static DBManager manager = null;

    private static boolean initialized = false;

    /** DataSource dove attingere connessioni */
    private DataSource dataSource = null;

    private String dataSourceName = null;
    private java.util.Properties dataSourceContext = null;
    public String getDataSourceName() {
        return this.dataSourceName;
    }

    public java.util.Properties getDataSourceContext() {
        return this.dataSourceContext;
    }
    
    /**
     * Viene chiamato in causa per istanziare il datasource
     * 
     * @param jndiName
     *            Nome JNDI del Datasource
     * @param context
     *            Contesto JNDI da utilizzare
     */
    private DBManager(String jndiName, java.util.Properties context) throws Exception {
        try {
            DBManager.log = ControlStationLogger.getPddConsoleCoreLogger();
            this.dataSourceName = jndiName;
            this.dataSourceContext = context;
            
            if (context != null) {
                DBManager.log.info("Proprieta' di contesto:" + context.size());
                Enumeration<?> en = context.keys();
                while (en.hasMoreElements()) {
                    String key = (String) en.nextElement();
                    DBManager.log.info("\tNome[" + key + "] Valore[" + context.getProperty(key) + "]");
                }
            } else {
                DBManager.log.info("Proprieta' di contesto non fornite");
            }

            DBManager.log.info("Nome dataSource:" + jndiName);

            InitialContext initC = null;
            if (context != null && context.size() > 0)
                initC = new InitialContext(context);
            else
                initC = new InitialContext();
            this.dataSource = (DataSource) initC.lookup(jndiName);
            initC.close();

        } catch (Exception e) {
            DBManager.log.error("Lookup datasource non riuscita", e);
            throw e;
        }
    }

    /**
     * Il Metodo si occupa di inizializzare il propertiesReader del QueueManager
     * 
     * @param jndiName
     *            Nome JNDI del Datasource
     * @param context
     *            Contesto JNDI da utilizzare
     */
    public static boolean initialize(String jndiName, java.util.Properties context) throws Exception {
        if (DBManager.manager == null) {
            initializeEngine(jndiName, context);
        }
        return DBManager.initialized;
    }
    private static synchronized void initializeEngine(String jndiName, java.util.Properties context) throws Exception {
        try {
            if (DBManager.manager == null) {
                DBManager.manager = new DBManager(jndiName, context);
                DBManager.setInitialized(true);
            }
        } catch (Exception e) {
            DBManager.setInitialized(false);
            DBManager.log.debug("Errore di inizializzazione del Database", e);
            throw e;
        }
    }

    /**
     * Ritorna l'istanza di questo DBManager
     * 
     * @return Istanza di DBManager
     */
    public static DBManager getInstance() {
        if(DBManager.manager==null) {
            // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED': l'istanza viene creata allo startup
            synchronized (DBManager.class) {
                return DBManager.manager;
            }
        }
        return DBManager.manager;
    }

    /**
     * Viene chiamato in causa per ottenere una connessione al DB
     */
    public java.sql.Connection getConnection() {
        if (this.dataSource == null) {
            return null;
        }

        Connection connectionDB = null;
        try {
            connectionDB = this.dataSource.getConnection();
        } catch (Exception e) {
            DBManager.log.error("getConnection from db", e);
            return null;
        }

        return connectionDB;
    }

    /**
     * Viene chiamato in causa per rilasciare una connessione al DB, effettuando
     * precedentemente un commit
     * 
     * @param connectionDB
     *            Connessione da rilasciare.
     */
    public void releaseConnection(java.sql.Connection connectionDB) {
        try {
            JDBCUtilities.closeConnection(checkLogger, connectionDB, checkAutocommit, checkIsClosed);
        } catch (SQLException e) {
            DBManager.log.error("closeConnection db", e);
        }
    }

    public static boolean isInitialized() {
        return DBManager.initialized;
    }

    private static void setInitialized(boolean initialized) {
        DBManager.initialized = initialized;
    }
}