DBManager.java

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


  22. package org.openspcoop2.core.monitor.rs.server.config;

  24. import java.sql.Connection;
  25. import java.sql.SQLException;
  26. import java.util.Enumeration;

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

  31. import org.openspcoop2.generic_project.utils.ServiceManagerProperties;
  32. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  33. import org.slf4j.Logger;

  35. /**
  36.  * DBManager
  37.  * 
  38.  * @author Andrea Poli (apoli@link.it)
  39.  * @author $Author$
  40.  * @version $Rev$, $Date$
  41.  * 
  42.  */
  43. public class DBManager {

  45.     private static Logger checkLogger = null;
  46.     private static boolean checkIsClosed = true;
  47.     private static boolean checkAutocommit = true;
  48.     public static boolean isCheckIsClosed() {
  49.         return checkIsClosed;
  50.     }
  51.     public static void setCheckIsClosed(boolean checkIsClosed) {
  52.         DBManager.checkIsClosed = checkIsClosed;
  53.     }
  54.     public static boolean isCheckAutocommit() {
  55.         return checkAutocommit;
  56.     }
  57.     public static void setCheckAutocommit(boolean checkAutocommit) {
  58.         DBManager.checkAutocommit = checkAutocommit;
  59.     }
  60.     public static Logger getCheckLogger() {
  61.         return checkLogger;
  62.     }
  63.     public static void setCheckLogger(Logger checkLogger) {
  64.         DBManager.checkLogger = checkLogger;
  65.     }
  66.     
  67.     /** Logger utilizzato per debug. */
  68.     private static Logger log = null;

  70.     /** DBManager */
  71.     private static DBManager manager = null;

  73.     private static boolean initialized = false;

  75.     /** DataSource dove attingere connessioni della configurazione */

  77.     private ServiceManagerProperties serviceManagerPropertiesConfig;
  78.     public ServiceManagerProperties getServiceManagerPropertiesConfig() {
  79.         return this.serviceManagerPropertiesConfig;
  80.     }
  81.     
  82.     private DataSource dataSourceConfig = null;

  84.     private String dataSourceConfigName = null;
  85.     private java.util.Properties dataSourceConfigContext = null;
  86.     public String getDataSourceConfigName() {
  87.         return this.dataSourceConfigName;
  88.     }

  90.     public java.util.Properties getDataSourceConfigContext() {
  91.         return this.dataSourceConfigContext;
  92.     }
  93.     
  94.     /** DataSource dove attingere connessioni delle tracce */
  95.     
  96.     private ServiceManagerProperties serviceManagerPropertiesTracce;
  97.     public ServiceManagerProperties getServiceManagerPropertiesTracce() {
  98.         return this.serviceManagerPropertiesTracce;
  99.     }
  100.     
  101.     private DataSource dataSourceTracce = null;

  103.     private String dataSourceTracceName = null;
  104.     private java.util.Properties dataSourceTracceContext = null;
  105.     public String getDataSourceTracceName() {
  106.         return this.dataSourceTracceName;
  107.     }

  109.     public java.util.Properties getDataSourceTracceContext() {
  110.         return this.dataSourceTracceContext;
  111.     }
  112.     
  113.     /** DataSource dove attingere connessioni delle statistiche */
  114.     
  115.     private ServiceManagerProperties serviceManagerPropertiesStatistiche;
  116.     public ServiceManagerProperties getServiceManagerPropertiesStatistiche() {
  117.         return this.serviceManagerPropertiesStatistiche;
  118.     }
  119.     
  120.     private DataSource dataSourceStatistiche = null;

  122.     private String dataSourceStatisticheName = null;
  123.     private java.util.Properties dataSourceStatisticheContext = null;
  124.     public String getDataSourceStatisticheName() {
  125.         return this.dataSourceStatisticheName;
  126.     }

  128.     public java.util.Properties getDataSourceStatisticheContext() {
  129.         return this.dataSourceStatisticheContext;
  130.     }
  131.     
  132.     
  133.     
  134.     /**
  135.      * Viene chiamato in causa per istanziare il datasource
  136.      * 
  137.      * @param jndiName
  138.      *            Nome JNDI del Datasource
  139.      * @param context
  140.      *            Contesto JNDI da utilizzare
  141.      */
  142.     private DBManager(String jndiNameConfig, java.util.Properties contextConfig, String tipoDBConfig, 
  143.             String jndiNameTracce, java.util.Properties contextTracce, String tipoDBTracce, 
  144.             String jndiNameStatistiche, java.util.Properties contextStatistiche, String tipoDBStatistiche, 
  145.             boolean debug) throws Exception {
  146.         try {
  147.             DBManager.log = LoggerProperties.getLoggerCore();
  148.             
  149.             
  150.             /** DataSource dove attingere connessioni della configurazione */
  151.             
  152.             this.dataSourceConfigName = jndiNameConfig;
  153.             this.dataSourceConfigContext = contextConfig;
  154.             
  155.             if (this.dataSourceConfigContext != null) {
  156.                 DBManager.log.info("Proprieta' di contesto:" + this.dataSourceConfigContext.size());
  157.                 Enumeration<?> en = this.dataSourceConfigContext.keys();
  158.                 while (en.hasMoreElements()) {
  159.                     String key = (String) en.nextElement();
  160.                     DBManager.log.info("\tNome[" + key + "] Valore[" + this.dataSourceConfigContext.getProperty(key) + "]");
  161.                 }
  162.             } else {
  163.                 DBManager.log.info("Proprieta' di contesto non fornite");
  164.             }

  166.             DBManager.log.info("Nome dataSource:" + this.dataSourceConfigName);

  168.             InitialContext initC = null;
  169.             if (this.dataSourceConfigContext != null && this.dataSourceConfigContext.size() > 0)
  170.                 initC = new InitialContext(this.dataSourceConfigContext);
  171.             else
  172.                 initC = new InitialContext();
  173.             this.dataSourceConfig = (DataSource) initC.lookup(this.dataSourceConfigName);
  174.             initC.close();
  175.             
  176.             this.serviceManagerPropertiesConfig = new ServiceManagerProperties();
  177.             this.serviceManagerPropertiesConfig.setDatabaseType(tipoDBConfig);
  178.             this.serviceManagerPropertiesConfig.setShowSql(debug);
  179.             
  180.             
  181.             /** DataSource dove attingere connessioni per le tracce */
  182.             
  183.             this.dataSourceTracceName = jndiNameTracce;
  184.             this.dataSourceTracceContext = contextTracce;
  185.             
  186.             if (this.dataSourceTracceContext != null) {
  187.                 DBManager.log.info("Proprieta' di contesto:" + this.dataSourceTracceContext.size());
  188.                 Enumeration<?> en = this.dataSourceTracceContext.keys();
  189.                 while (en.hasMoreElements()) {
  190.                     String key = (String) en.nextElement();
  191.                     DBManager.log.info("\tNome[" + key + "] Valore[" + this.dataSourceTracceContext.getProperty(key) + "]");
  192.                 }
  193.             } else {
  194.                 DBManager.log.info("Proprieta' di contesto non fornite");
  195.             }

  197.             DBManager.log.info("Nome dataSource:" + this.dataSourceTracceName);

  199.             initC = null;
  200.             if (this.dataSourceTracceContext != null && this.dataSourceTracceContext.size() > 0)
  201.                 initC = new InitialContext(this.dataSourceTracceContext);
  202.             else
  203.                 initC = new InitialContext();
  204.             this.dataSourceTracce = (DataSource) initC.lookup(this.dataSourceTracceName);
  205.             initC.close();
  206.             
  207.             this.serviceManagerPropertiesTracce = new ServiceManagerProperties();
  208.             this.serviceManagerPropertiesTracce.setDatabaseType(tipoDBTracce);
  209.             this.serviceManagerPropertiesTracce.setShowSql(debug);
  210.             
  211.             
  212.             /** DataSource dove attingere connessioni per le statistiche */
  213.             
  214.             this.dataSourceStatisticheName = jndiNameStatistiche;
  215.             this.dataSourceStatisticheContext = contextStatistiche;
  216.             
  217.             if (this.dataSourceStatisticheContext != null) {
  218.                 DBManager.log.info("Proprieta' di contesto:" + this.dataSourceStatisticheContext.size());
  219.                 Enumeration<?> en = this.dataSourceStatisticheContext.keys();
  220.                 while (en.hasMoreElements()) {
  221.                     String key = (String) en.nextElement();
  222.                     DBManager.log.info("\tNome[" + key + "] Valore[" + this.dataSourceStatisticheContext.getProperty(key) + "]");
  223.                 }
  224.             } else {
  225.                 DBManager.log.info("Proprieta' di contesto non fornite");
  226.             }

  228.             DBManager.log.info("Nome dataSource:" + this.dataSourceStatisticheName);

  230.             initC = null;
  231.             if (this.dataSourceStatisticheContext != null && this.dataSourceStatisticheContext.size() > 0)
  232.                 initC = new InitialContext(this.dataSourceStatisticheContext);
  233.             else
  234.                 initC = new InitialContext();
  235.             this.dataSourceStatistiche = (DataSource) initC.lookup(this.dataSourceStatisticheName);
  236.             initC.close();
  237.             
  238.             this.serviceManagerPropertiesStatistiche = new ServiceManagerProperties();
  239.             this.serviceManagerPropertiesStatistiche.setDatabaseType(tipoDBStatistiche);
  240.             this.serviceManagerPropertiesStatistiche.setShowSql(debug);

  242.         } catch (Exception e) {
  243.             DBManager.log.error("Lookup datasource non riuscita", e);
  244.             throw e;
  245.         }
  246.     }

  248.     /**
  249.      * Il Metodo si occupa di inizializzare il propertiesReader del QueueManager
  250.      * 
  251.      */
  252.     public static synchronized boolean initialize(String jndiNameConfig, java.util.Properties contextConfig, String tipoDBConfig, 
  253.             String jndiNameTracce, java.util.Properties contextTracce, String tipoDBTracce, 
  254.             String jndiNameStatistiche, java.util.Properties contextStatistiche, String tipoDBStatistiche, 
  255.             boolean debug) throws Exception {
  256.         try {
  257.             if (DBManager.manager == null) {
  258.                 DBManager.manager = new DBManager(jndiNameConfig, contextConfig, tipoDBConfig, 
  259.                         jndiNameTracce, contextTracce, tipoDBTracce,
  260.                         jndiNameStatistiche, contextStatistiche, tipoDBStatistiche,
  261.                         debug);
  262.                 DBManager.setInitialized(true);
  263.             }
  264.             return true;
  265.         } catch (Exception e) {
  266.             DBManager.setInitialized(false);
  267.             DBManager.log.debug("Errore di inizializzazione del Database", e);
  268.             throw e;
  269.         }
  270.     }

  272.     /**
  273.      * Ritorna l'istanza di questo DBManager
  274.      * 
  275.      * @return Istanza di DBManager
  276.      */
  277.     public static DBManager getInstance() {
  278.         // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED': l'istanza viene creata allo startup
  279.         if(DBManager.manager==null) {
  280.             synchronized (DBManager.class) {
  281.                 return DBManager.manager;
  282.             }
  283.         }
  284.         return DBManager.manager;
  285.     }

  287.     /**
  288.      * Viene chiamato in causa per ottenere una connessione al DB
  289.      */
  290.     public java.sql.Connection getConnectionConfig() {
  291.         if (this.dataSourceConfig == null) {
  292.             return null;
  293.         }

  295.         Connection connectionDB = null;
  296.         try {
  297.             connectionDB = this.dataSourceConfig.getConnection();
  298.         } catch (Exception e) {
  299.             DBManager.log.error("getConnectionConfig from db", e);
  300.             return null;
  301.         }

  303.         return connectionDB;
  304.     }

  306.     /**
  307.      * Viene chiamato in causa per rilasciare una connessione al DB, effettuando
  308.      * precedentemente un commit
  309.      * 
  310.      * @param connectionDB
  311.      *            Connessione da rilasciare.
  312.      */
  313.     public void releaseConnectionConfig(java.sql.Connection connectionDB) {
  314.         try {
  315.             JDBCUtilities.closeConnection(checkLogger, connectionDB, checkAutocommit, checkIsClosed);
  316.         } catch (SQLException e) {
  317.             DBManager.log.error("closeConnection config db", e);
  318.         }
  319.     }
  320.     
  321.     /**
  322.      * Viene chiamato in causa per ottenere una connessione al DB
  323.      */
  324.     public java.sql.Connection getConnectionTracce() {
  325.         if (this.dataSourceTracce == null) {
  326.             return null;
  327.         }

  329.         Connection connectionDB = null;
  330.         try {
  331.             connectionDB = this.dataSourceTracce.getConnection();
  332.         } catch (Exception e) {
  333.             DBManager.log.error("getConnectionTracce from db", e);
  334.             return null;
  335.         }

  337.         return connectionDB;
  338.     }

  340.     /**
  341.      * Viene chiamato in causa per rilasciare una connessione al DB, effettuando
  342.      * precedentemente un commit
  343.      * 
  344.      * @param connectionDB
  345.      *            Connessione da rilasciare.
  346.      */
  347.     public void releaseConnectionTracce(java.sql.Connection connectionDB) {
  348.         try {
  349.             JDBCUtilities.closeConnection(checkLogger, connectionDB, checkAutocommit, checkIsClosed);
  350.         } catch (SQLException e) {
  351.             DBManager.log.error("closeConnection tracce db", e);
  352.         }
  353.     }

  355.     /**
  356.      * Viene chiamato in causa per ottenere una connessione al DB
  357.      */
  358.     public java.sql.Connection getConnectionStatistiche() {
  359.         if (this.dataSourceStatistiche == null) {
  360.             return null;
  361.         }

  363.         Connection connectionDB = null;
  364.         try {
  365.             connectionDB = this.dataSourceStatistiche.getConnection();
  366.         } catch (Exception e) {
  367.             DBManager.log.error("getConnectionStatistiche from db", e);
  368.             return null;
  369.         }

  371.         return connectionDB;
  372.     }

  374.     /**
  375.      * Viene chiamato in causa per rilasciare una connessione al DB, effettuando
  376.      * precedentemente un commit
  377.      * 
  378.      * @param connectionDB
  379.      *            Connessione da rilasciare.
  380.      */
  381.     public void releaseConnectionStatistiche(java.sql.Connection connectionDB) {
  382.         try {
  383.             JDBCUtilities.closeConnection(checkLogger, connectionDB, checkAutocommit, checkIsClosed);
  384.         } catch (SQLException e) {
  385.             DBManager.log.error("closeConnection statistiche db", e);
  386.         }
  387.     }

  389.     
  390.     public static boolean isInitialized() {
  391.         return DBManager.initialized;
  392.     }

  394.     private static void setInitialized(boolean initialized) {
  395.         DBManager.initialized = initialized;
  396.     }
  397. }
Created with JaCoCo 0.8.8.202204050719