DataSourceFactory.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.  */

  21. package org.openspcoop2.utils.datasource;

  23. import java.text.SimpleDateFormat;
  24. import java.util.ArrayList;
  25. import java.util.Collection;
  26. import java.util.Collections;
  27. import java.util.Enumeration;
  28. import java.util.Iterator;
  29. import java.util.List;
  30. import java.util.Map;
  31. import java.util.Properties;
  32. import java.util.concurrent.ConcurrentHashMap;

  34. import javax.naming.RefAddr;

  36. import org.openspcoop2.utils.Utilities;
  37. import org.openspcoop2.utils.UtilsAlreadyExistsException;
  38. import org.openspcoop2.utils.UtilsException;
  39. import org.openspcoop2.utils.date.DateUtils;
  40. import org.openspcoop2.utils.jmx.RisorseJMXException;
  41. import org.openspcoop2.utils.resources.GestoreJNDI;

  43. /**
  44.  * DatasourceFactory
  45.  *   
  46.  * @author Poli Andrea (apoli@link.it)
  47.  * @author $Author$
  48.  * @version $Rev$, $Date$
  49.  */
  50. public class DataSourceFactory {

  52.     private static Map<String, org.openspcoop2.utils.datasource.DataSource> mapUUIDtoDatasources = new ConcurrentHashMap<String, org.openspcoop2.utils.datasource.DataSource>();
  53.     private static Map<String, String> mapApplicativeIDtoUUID = new ConcurrentHashMap<String, String>();
  54.     private static Map<String, String> mapJndiNametoUUID = new ConcurrentHashMap<String, String>();
  55.     private static org.openspcoop2.utils.jmx.GestoreRisorseJMX gestoreRisorse = null;
  56.     
  57.     private static synchronized void initGestoreRisorseJMX() throws RisorseJMXException{
  58.         if(gestoreRisorse==null)
  59.             gestoreRisorse = new org.openspcoop2.utils.jmx.GestoreRisorseJMX();
  60.     }
  61.     
  62.     public static int sizeDatasources(){
  63.         return mapUUIDtoDatasources.size();
  64.     }
  65.     
  66.     public static List<String> getJndiNameDatasources() {
  67.         if(mapJndiNametoUUID==null || mapJndiNametoUUID.isEmpty()) {
  68.             return null;
  69.         }
  70.         List<String> l = new ArrayList<>();
  71.         l.addAll(mapJndiNametoUUID.keySet());
  72.         return l;
  73.     }
  74.     
  75.     public static List<String> getApplicativeIdDatasources() {
  76.         if(mapApplicativeIDtoUUID==null || mapApplicativeIDtoUUID.isEmpty()) {
  77.             return null;
  78.         }
  79.         List<String> l = new ArrayList<>();
  80.         l.addAll(mapApplicativeIDtoUUID.keySet());
  81.         return l;
  82.     }
  83.     
  84.     public static String[] getJmxStatus() throws UtilsException{    
  85.         if(mapUUIDtoDatasources==null || mapUUIDtoDatasources.size()<=0)
  86.             return null;
  87.     
  88.         Collection<org.openspcoop2.utils.datasource.DataSource> list = mapUUIDtoDatasources.values();
  89.         Iterator<org.openspcoop2.utils.datasource.DataSource> it = list.iterator();
  90.         List<String> listResource = new ArrayList<>();
  91.         while (it.hasNext()) {
  92.             org.openspcoop2.utils.datasource.DataSource datasource = (org.openspcoop2.utils.datasource.DataSource) it.next();
  93.             StringBuilder bf = new StringBuilder();
  94.             SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  95.             bf.append("(").append(dateformat.format(datasource.getDate())).append(") ");
  96.             bf.append("idDatasource:");
  97.             bf.append(datasource.getUuidDatasource());
  98.             if(datasource.getJndiName()!=null){
  99.                 if(bf.length() > 0){
  100.                     bf.append(" ");
  101.                 }
  102.                 bf.append("jndiName:");
  103.                 bf.append(datasource.getJndiName());
  104.             }
  105.             if(datasource.getApplicativeIdDatasource()!=null){
  106.                 if(bf.length() > 0){
  107.                     bf.append(" ");
  108.                 }
  109.                 bf.append("idApplicativo:");
  110.                 bf.append(datasource.getApplicativeIdDatasource());
  111.             }
  112.             if(bf.length() > 0){
  113.                 bf.append(" ");
  114.             }
  115.             bf.append("ConnessioniAttive:");
  116.             bf.append(datasource.size());
  117.             listResource.add(bf.toString());
  118.         }
  119.         if(listResource.size()>0){
  120.             Collections.sort(listResource);
  121.             return listResource.toArray(new String[1]);
  122.         }else
  123.             return null;
  124.         
  125.     }
  126.     
  127.     
  128.     // **** Metodi per la creazione ***
  129.     
  130.     public static org.openspcoop2.utils.datasource.DataSource newInstance(String jndiName,Properties jndiContext, DataSourceParams params) throws UtilsException, UtilsAlreadyExistsException{
  131.         if(jndiContext==null){
  132.             jndiContext = new Properties();
  133.         }
  134.         GestoreJNDI jndi = new GestoreJNDI(jndiContext);
  135.         Object oSearch = null;
  136.         try{
  137.             oSearch = jndi.lookup(jndiName);
  138.         }catch(Throwable t){
  139.             throw new UtilsException("Lookup jndiResource ["+jndiName+"] failed: "+t.getMessage(),t);
  140.         }
  141.         if(oSearch==null){
  142.             throw new UtilsException("Lookup jndiResource ["+jndiName+"] not found");
  143.         }
  144.         javax.sql.DataSource datasource = null;
  145.         try{
  146.             datasource = (javax.sql.DataSource) oSearch;
  147.         }catch(Throwable t){
  148.             StringBuilder bf = new StringBuilder();
  149.             if(oSearch instanceof javax.naming.Reference){
  150.                 javax.naming.Reference r = (javax.naming.Reference) oSearch;
  151.                 bf.append(" (Factory=");
  152.                 bf.append(r.getFactoryClassName());
  153.                 bf.append(" FactoryLocation=");
  154.                 bf.append(r.getFactoryClassLocation());
  155.                 Enumeration<RefAddr> enR = r.getAll();
  156.                 if(enR!=null){
  157.                     while (enR.hasMoreElements()) {
  158.                         RefAddr refAddr = (RefAddr) enR.nextElement();
  159.                         bf.append(" [").
  160.                             append("type=").
  161.                             append(refAddr.getType()).
  162.                             append(" content=").
  163.                             append(refAddr.getContent()).
  164.                             append("]");
  165.                     }
  166.                 }
  167.                 bf.append(")");
  168.             }
  169.             throw new UtilsException("lookup failed (object class: "+oSearch.getClass().getName()+")"+bf.toString()+": "+t.getMessage(),t);
  170.         }
  171.         
  172.         return newInstance(datasource, params, jndiName);
  173.     }

  175.     public static org.openspcoop2.utils.datasource.DataSource newInstance(javax.sql.DataSource datasource, DataSourceParams params) throws UtilsException, UtilsAlreadyExistsException{
  176.         return newInstance(datasource, params, null);
  177.     }
  178.     
  179.     public static synchronized DataSource newInstance(javax.sql.DataSource datasource, DataSourceParams params, String jndiName) throws UtilsException, UtilsAlreadyExistsException{
  180.         
  181.         if(params==null){
  182.             throw new UtilsException("Parameters undefined");
  183.         }
  184.         if(params.getDatabaseType()==null){
  185.             throw new UtilsException("Parameters.databaseType undefined");
  186.         }
  187.         try{
  188.             if(params.getApplicativeId()!=null){
  189.                 if(mapApplicativeIDtoUUID.containsKey(params.getApplicativeId())){
  190.                     throw new UtilsAlreadyExistsException("Datasource with applicative id ["+params.getApplicativeId()+"] already exists");
  191.                 }
  192.             }
  193.             
  194.             if(jndiName!=null){
  195.                 if(mapJndiNametoUUID.containsKey(jndiName)){
  196.                     throw new UtilsAlreadyExistsException("Datasource with jndiName ["+jndiName+"] already exists");
  197.                 }
  198.             }
  199.             
  200.             org.openspcoop2.utils.datasource.DataSource ds = 
  201.                     new org.openspcoop2.utils.datasource.DataSource(datasource, params.getDatabaseType(), params.isWrapOriginalMethods(), jndiName, params.getApplicativeId());
  202.             
  203.             String uuidDatasource = ds.getUuidDatasource();
  204.             mapUUIDtoDatasources.put(uuidDatasource, ds);
  205.             if(params.getApplicativeId()!=null){
  206.                 mapApplicativeIDtoUUID.put(params.getApplicativeId(), uuidDatasource);
  207.             }
  208.             if(jndiName!=null){
  209.                 mapJndiNametoUUID.put(jndiName, uuidDatasource);
  210.             }
  211.         
  212.             if(params.isBindJmx()){
  213.                 if(gestoreRisorse==null){
  214.                     initGestoreRisorseJMX();
  215.                     gestoreRisorse.registerMBean(JmxDataSource.class, params.getJmxDomain(), params.getJmxType(), params.getJmxName(), false);
  216.                 }
  217.             }
  218.             
  219.             return ds;
  220.         }
  221.         catch(UtilsAlreadyExistsException e){
  222.             throw e;
  223.         }
  224.         catch(Exception e){
  225.             throw new UtilsException(e.getMessage(),e);
  226.         }
  227.         
  228.     }
  229.     
  230.     // **** Metodi per recuperare il datasource ***
  231.     
  232.     public static org.openspcoop2.utils.datasource.DataSource getInstance(String id) throws UtilsException{
  233.         String uuid = id;
  234.         if(mapApplicativeIDtoUUID.containsKey(id)){
  235.             uuid = mapApplicativeIDtoUUID.get(id);
  236.         }
  237.         else if(mapJndiNametoUUID.containsKey(id)){
  238.             uuid = mapJndiNametoUUID.get(id);
  239.         }
  240.         org.openspcoop2.utils.datasource.DataSource d = mapUUIDtoDatasources.get(uuid);
  241.         if(d==null){
  242.             throw new UtilsException("Datasource with id ["+id+"] not exists");
  243.         }
  244.         return d;
  245.     }

  247.     // **** Metodi per rilasciare le risorse ***
  248.     public static void closeResources() throws UtilsException{

  250.         mapApplicativeIDtoUUID.clear();
  251.         mapJndiNametoUUID.clear();

  253.         Collection<org.openspcoop2.utils.datasource.DataSource> list = mapUUIDtoDatasources.values();
  254.         Iterator<org.openspcoop2.utils.datasource.DataSource> it = list.iterator();
  255.         while (it.hasNext()) {
  256.             org.openspcoop2.utils.datasource.DataSource datasource = (org.openspcoop2.utils.datasource.DataSource) it.next();
  257.             datasource.setClosed(true);
  258.         }
  259.         
  260.         boolean waitCloseConnection = true;
  261.         int maxWait = 60000;
  262.         int sleep = 1000;
  263.         int index = 0;
  264.         int count = 1;
  265.         int total = maxWait / sleep;
  266.         while(waitCloseConnection && index<maxWait){
  267.             list = mapUUIDtoDatasources.values();
  268.             it = list.iterator();
  269.             boolean closeAll = true;
  270.             StringBuilder bf = new StringBuilder();
  271.             boolean debugClose = true;
  272.             while (it.hasNext()) {
  273.                 org.openspcoop2.utils.datasource.DataSource datasource = (org.openspcoop2.utils.datasource.DataSource) it.next();
  274.                 if(datasource.size()>0){
  275.                     closeAll = false;
  276.                     bf.append("Find datasource (applicative-id:"+datasource.getApplicativeIdDatasource()+" jndi:"+datasource.getJndiName()+") with "+datasource.size()+" released connection:");
  277.                     String[] status = datasource.getJmxStatus();
  278.                     if(status!=null) {
  279.                         for (int i = 0; i < status.length; i++) {
  280.                             bf.append("\n");
  281.                             bf.append("\t"+status[i]);
  282.                         }
  283.                     }
  284.                     break;
  285.                 }
  286.             }
  287.             if(closeAll==false){
  288.                 if(debugClose && ((count%5)==0)) {
  289.                     // stampo la situazione ogni 5 secondi
  290.                     System.out.println(bf.toString());
  291.                 }
  292.                 System.out.println("Wait close connection ("+count+"/"+total+") ...");
  293.                 Utilities.sleep(sleep);
  294.                 index = index + sleep;
  295.                 count++;
  296.             }
  297.             else{
  298.                 waitCloseConnection = false;
  299.             }
  300.         }
  301.         if(waitCloseConnection==true){
  302.             System.out.println("Forzo chiusura connessioni");
  303.             // forzo chiusura connessioni
  304.             list = mapUUIDtoDatasources.values();
  305.             it = list.iterator();
  306.             while (it.hasNext()) {
  307.                 org.openspcoop2.utils.datasource.DataSource datasource = (org.openspcoop2.utils.datasource.DataSource) it.next();
  308.                 if(datasource.size()>0){
  309.                     datasource.releaseConnnections();
  310.                 }
  311.             }
  312.         }
  313.         mapUUIDtoDatasources.clear();   
  314.         
  315.         if(gestoreRisorse!=null){
  316.             gestoreRisorse.unregisterMBeans();
  317.         }
  318.     }
  319. }
Created with JaCoCo 0.8.8.202204050719