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



  23. package org.openspcoop2.protocol.basic;

  25. import java.sql.Connection;
  26. import java.sql.DriverManager;
  27. import java.sql.SQLException;
  28. import java.sql.Statement;
  29. import java.util.HashMap;
  30. import java.util.Properties;

  32. import javax.sql.DataSource;

  34. import org.openspcoop2.core.commons.CoreException;
  35. import org.openspcoop2.core.commons.IMonitoraggioRisorsa;
  36. import org.openspcoop2.core.config.OpenspcoopAppender;
  37. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  38. import org.openspcoop2.protocol.sdk.ProtocolException;
  39. import org.openspcoop2.protocol.sdk.config.IProtocolConfiguration;
  40. import org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnosticoException;
  41. import org.openspcoop2.utils.TipiDatabase;
  42. import org.openspcoop2.utils.Utilities;
  43. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  44. import org.openspcoop2.utils.resources.GestoreJNDI;


  47. /**
  48.  * Contiene l'implementazione di un appender personalizzato,
  49.  * per la registrazione su database.
  50.  *
  51.  * @author Poli Andrea (apoli@link.it)
  52.  * @author $Author$
  53.  * @version $Rev$, $Date$
  54.  */
  55. public class BasicProducer extends BasicComponentFactory implements IMonitoraggioRisorsa {
  56.     
  57.     /** Properties */
  58.     protected Properties appenderProperties;
  59.         
  60.     /** DataSource dove attingere connessioni */
  61.     protected DataSource ds = null;
  62.     protected String datasource = null;
  63.    
  64.     /** Connessione diretta via JDBC */
  65.     protected String connectionViaJDBCUrl = null;
  66.     protected String connectionViaJDBCDriverJDBC = null;
  67.     protected String connectionViaJDBCUsername = null;
  68.     protected String connectionViaJDBCPassword = null;

  70.     /** SingleConnection */
  71.     protected boolean singleConnection = false;
  72.     protected HashMap<BasicProducerType, Connection> singleConnectionConnectionMap = new HashMap<>(); 
  73.     protected HashMap<BasicProducerType, String> singleConnectionSourceMap = new HashMap<>(); 
  74.     
  75.     /** TipoDatabase */
  76.     protected String tipoDatabase = null; 

  78.     /** OpenSPCoop Connection */
  79.     protected boolean openspcoopConnection = false;
  80.     
  81.     /** Emit debug info */
  82.     protected boolean debug = false;

  84.     /** forceIndex */
  85.     protected boolean forceIndex = false;
  86.     public void setForceIndex(boolean forceIndex) {
  87.         this.forceIndex = forceIndex;
  88.     }
  89.     
  90.     /** IProtocolConfiguration */
  91.     protected IProtocolConfiguration protocolConfiguration;
  92.     
  93.     /** ISAlive */
  94.     protected boolean isAlive = true;
  95.     
  96.     private BasicProducerType producerType;
  97.     
  98.     public BasicProducer(IProtocolFactory<?> factory, BasicProducerType producerType) throws ProtocolException{
  99.         super(factory);
  100.         this.producerType = producerType;
  101.     }
  102.     
  103.     

  105.     protected synchronized void initConnection(DataSource dsA,String dataSourceS)throws ProtocolException{
  106.         Connection singleConnectionConnection = this.singleConnectionConnectionMap.get(this.producerType);
  107.         if(singleConnectionConnection==null){
  108.             try{
  109.                 String singleConnectionSource = dataSourceS;
  110.                 singleConnectionConnection = dsA.getConnection();
  111.                 this.singleConnectionConnectionMap.put(this.producerType, singleConnectionConnection);
  112.                 this.singleConnectionSourceMap.put(this.producerType, singleConnectionSource);
  113.             }catch(Exception e){
  114.                  throw new ProtocolException("Inizializzazione single connection (via datasource) non riuscita",e);
  115.             }
  116.         }
  117.     }
  118.     protected synchronized void initConnection(String jdbcUrl,String jdbcDriver,String username, String password)throws ProtocolException{
  119.         Connection singleConnectionConnection = this.singleConnectionConnectionMap.get(this.producerType);
  120.         if(singleConnectionConnection==null){
  121.             try{
  122.                 String singleConnectionSource = "url:"+jdbcUrl+" driver:"+jdbcDriver+" username:"+username+" password:"+password;
  123.                 if(username==null){
  124.                     singleConnectionConnection = DriverManager.getConnection(jdbcUrl);
  125.                 }
  126.                 else{
  127.                     singleConnectionConnection = DriverManager.getConnection(jdbcUrl,username,password);
  128.                 }
  129.                 this.singleConnectionConnectionMap.put(this.producerType, singleConnectionConnection);
  130.                 this.singleConnectionSourceMap.put(this.producerType, singleConnectionSource);
  131.             }catch(Exception e){
  132.                  throw new ProtocolException("Inizializzazione single connection (via jdbc connection) non riuscita",e);
  133.             }
  134.         }
  135.     }
  136.     protected Connection getConnectionViaJDBC() throws SQLException{
  137.         if(this.connectionViaJDBCUsername==null){
  138.             return DriverManager.getConnection(this.connectionViaJDBCUrl);
  139.         }
  140.         else{
  141.             return DriverManager.getConnection(this.connectionViaJDBCUrl,
  142.                     this.connectionViaJDBCUsername,this.connectionViaJDBCPassword);
  143.         }
  144.     }
  145.     
  146.     protected BasicConnectionResult getConnection(Connection conOpenSPCoopPdD,String methodName) throws ProtocolException{
  147.         Connection con = null;
  148.         BasicConnectionResult cr = new BasicConnectionResult();
  149.         cr.setReleaseConnection(false);
  150.         if(this.debug){
  151.             this.logInfo("@@ ["+methodName+"] SINGLE CONNECTION["+this.singleConnection+"] OPEN["+this.openspcoopConnection+"]");
  152.         }
  153.         if(!this.singleConnection){
  154.             if(this.openspcoopConnection && conOpenSPCoopPdD!=null){
  155.                 /**System.out.println("["+methodName+"]@GET_CONNECTION@ USE CONNECTION OPENSPCOOP");*/
  156.                 if(this.debug){
  157.                     this.logInfo("@@ ["+methodName+"] GET_CONNECTION, USE CONNECTION OPENSPCOOP");
  158.                 }
  159.                 con = conOpenSPCoopPdD;
  160.             }else{
  161.                 if(this.ds!=null){
  162.                     try{
  163.                         con = this.ds.getConnection();
  164.                         /**if(con == null)
  165.                             throw new Exception("Connessione non fornita");*/
  166.                         cr.setReleaseConnection(true);
  167.                         /**System.out.println("["+methodName+"]@GET_CONNECTION@ USE CONNECTION FROM DATASOURCE");*/
  168.                         if(this.debug){
  169.                             this.logInfo("@@ ["+methodName+"] GET_CONNECTION, USE CONNECTION FROM DATASOURCE");
  170.                         }
  171.                     }catch(Exception e){
  172.                         throw new ProtocolException("Errore durante il recupero di una connessione dal datasource ["+this.datasource+"]: "+e.getMessage());
  173.                     }
  174.                 }
  175.                 else{
  176.                     try{
  177.                         con = this.getConnectionViaJDBC();
  178.                         if(con == null)
  179.                             throw new ProtocolException("Connessione non fornita");
  180.                         cr.setReleaseConnection(true);
  181.                         /**System.out.println("["+methodName+"]@GET_CONNECTION@ USE CONNECTION VIA JDBC");*/
  182.                         if(this.debug){
  183.                             this.logInfo("@@ ["+methodName+"] GET_CONNECTION, USE CONNECTION VIA JDBC");
  184.                         }
  185.                     }catch(Exception e){
  186.                         throw new ProtocolException("Errore durante il recupero di una connessione via jdbc url["+this.connectionViaJDBCUrl+"] driver["+
  187.                                 this.connectionViaJDBCDriverJDBC+"] username["+this.connectionViaJDBCUsername+"] password["+this.connectionViaJDBCPassword
  188.                                 +"]: "+e.getMessage());
  189.                     }
  190.                 }
  191.             }
  192.         }else{
  193.             con = this.singleConnectionConnectionMap.get(this.producerType);
  194.             if(con == null){
  195.                 throw new ProtocolException("Connessione (singleConnection enabled) non fornita dalla sorgente ["+this.singleConnectionSourceMap.get(this.producerType)+"]");
  196.             }
  197.             /**System.out.println("["+methodName+"]@GET_CONNECTION@ SINGLE CONNECTION");*/
  198.             if(this.debug){
  199.                 this.logInfo("@@ ["+methodName+"] GET_CONNECTION, SINGLE CONNECTION");
  200.             }
  201.         }
  202.         cr.setConnection(con);
  203.         return cr;
  204.     }
  205.     protected void releaseConnection(BasicConnectionResult connectionResult,String methodName) throws SQLException{
  206.         if(this.debug){
  207.             this.logInfo("@@ ["+methodName+"] RELEASE_CONNECTION ["+connectionResult.isReleaseConnection()+"]?");
  208.         }
  209.         if(connectionResult.isReleaseConnection()){
  210.             /**System.out.println("["+methodName+"]@RELEASE_CONNECTION@");*/
  211.             if(this.debug){
  212.                 this.logInfo("@@ ["+methodName+"] RELEASE_CONNECTION effettuato");
  213.             }
  214.             JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), connectionResult.getConnection(), BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  215.         }
  216.     }
  217.     

  219.     
  220.     

  222.     
  223.     /**
  224.      * Inizializza l'engine di un appender per la registrazione
  225.      * 
  226.      * @param appenderProperties Proprieta' dell'appender
  227.      * @throws MsgDiagnosticoException
  228.      */
  229.     public void initializeAppender(OpenspcoopAppender appenderProperties, boolean tipoDatabaseRequired) throws ProtocolException{
  230.         
  231.         try{
  232.         
  233.             // Lettura modalita' di gestione
  234.             this.appenderProperties = new Properties();
  235.             if(appenderProperties.sizePropertyList()>0){
  236.                 
  237.                 for(int i=0; i<appenderProperties.sizePropertyList(); i++){
  238.                     this.appenderProperties.put(appenderProperties.getProperty(i).getNome(),
  239.                             appenderProperties.getProperty(i).getValore());
  240.                 }
  241.                 
  242.                 this.datasource = this.appenderProperties.getProperty("datasource");
  243.                 if(this.datasource==null){
  244.                     this.connectionViaJDBCUrl = this.appenderProperties.getProperty("connectionUrl");
  245.                     if(this.connectionViaJDBCUrl==null){
  246.                         String tmp = this.appenderProperties.getProperty("checkProperties");
  247.                         if(tmp == null || Boolean.valueOf(tmp.trim())) {
  248.                             throw new ProtocolException("Proprietà 'datasource' e 'connectionUrl' non definite (almeno una delle due è obbligatoria)");
  249.                         }
  250.                         else {
  251.                             this.isAlive = false;
  252.                         }
  253.                     }
  254.                 }
  255.                 
  256.                 this.tipoDatabase=this.appenderProperties.getProperty("tipoDatabase");
  257.                 // non obbligatorio in msg diagnostico per retrocompatibilità
  258.                 if(this.tipoDatabase==null && tipoDatabaseRequired){
  259.                     throw new ProtocolException("Proprieta' 'tipoDatabase' non definita");
  260.                 }
  261.                 if(this.tipoDatabase!=null &&
  262.                     !TipiDatabase.isAMember(this.tipoDatabase)){
  263.                     throw new ProtocolException("Proprieta' 'tipoDatabase' presenta un tipo ["+this.tipoDatabase+"] non supportato");
  264.                 }
  265.                 
  266.                 String singleConnectionString = this.appenderProperties.getProperty("singleConnection");
  267.                 if(singleConnectionString!=null){
  268.                     singleConnectionString = singleConnectionString.trim();
  269.                     if("true".equals(singleConnectionString)){
  270.                         this.singleConnection = true;
  271.                     }
  272.                 }
  273.                 
  274.                 String openspcoopConnectionString = this.appenderProperties.getProperty("usePdDConnection");
  275.                 if(openspcoopConnectionString!=null){
  276.                     openspcoopConnectionString = openspcoopConnectionString.trim();
  277.                     if("true".equals(openspcoopConnectionString)){
  278.                         this.openspcoopConnection = true;
  279.                     }
  280.                 }
  281.                 
  282.             }else{
  283.                 throw new ProtocolException("Proprietà 'datasource' e 'connectionUrl' non definite (almeno una delle due è obbligatoria)");
  284.             }
  285.             
  286.             // Datasource
  287.             if(this.datasource!=null){
  288.                 
  289.                 java.util.Properties ctx = Utilities.readProperties("context-", this.appenderProperties);
  290.             
  291.                 GestoreJNDI jndi = new GestoreJNDI(ctx);
  292.                 if(this.singleConnection){
  293.                     if(this.singleConnectionConnectionMap.get(this.producerType)==null){
  294.                         DataSource dsL = (DataSource) jndi.lookup(this.datasource);
  295.                         initConnection(dsL,this.datasource);
  296.                     }
  297.                 }else{
  298.                     this.ds = (DataSource) jndi.lookup(this.datasource);
  299.                 }
  300.                 
  301.             }
  302.             
  303.             
  304.             // connectionViaJDBC
  305.             if(this.connectionViaJDBCUrl!=null){
  306.                 
  307.                 this.connectionViaJDBCDriverJDBC = this.appenderProperties.getProperty("connectionDriver");
  308.                 if(this.connectionViaJDBCDriverJDBC==null){
  309.                     throw new ProtocolException("Proprietà 'connectionDriver' non definita (obbligatoria nella modalita' 'connection via jdbc')");
  310.                 }
  311.                 
  312.                 this.connectionViaJDBCUsername = this.appenderProperties.getProperty("connectionUsername");
  313.                 if(this.connectionViaJDBCUsername!=null){
  314.                     this.connectionViaJDBCPassword = this.appenderProperties.getProperty("connectionPassword");
  315.                     if(this.connectionViaJDBCPassword==null){
  316.                         throw new ProtocolException("Proprietà 'connectionPassword' non definita (obbligatoria nella modalita' 'connection via jdbc' se viene definita la proprieta' 'connectionUsername')");
  317.                     }
  318.                 }
  319.                 
  320.                 Class.forName(this.connectionViaJDBCDriverJDBC);
  321.                 
  322.                 if(this.singleConnection &&
  323.                     this.singleConnectionConnectionMap.get(this.producerType)==null){
  324.                     initConnection(this.connectionViaJDBCUrl,this.connectionViaJDBCDriverJDBC,this.connectionViaJDBCUsername,this.connectionViaJDBCPassword);
  325.                 }
  326.             }
  327.             
  328.             // debug info
  329.             String debugS = this.appenderProperties.getProperty("debug");
  330.             if(debugS!=null){
  331.                 debugS = debugS.trim();
  332.                 if("true".equals(debugS)){
  333.                     this.debug = true;
  334.                 }
  335.             }
  336.             
  337.             
  338.             // Protocol Configuration
  339.             this.protocolConfiguration = this.protocolFactory.createProtocolConfiguration();
  340.             
  341.         }catch(Exception e){
  342.             throw new ProtocolException("Errore durante l'inizializzazione dell'appender: "+e.getMessage(),e);
  343.         }
  344.     }

  346.     protected String getSQLStringValue(String value){
  347.         if(value!=null && (!"".equals(value))){
  348.             return value;
  349.         }
  350.         else{
  351.             return null;
  352.         }
  353.     }
  354.     
  355.     
  356.     
  357.     public String getTipoDatabase() {
  358.         return this.tipoDatabase;
  359.     }

  361.     public void setTipoDatabase(String tipoDatabase) {
  362.         this.tipoDatabase = tipoDatabase;
  363.     }
  364.     

  366.     /**
  367.      * Metodo che verica la connessione ad una risorsa.
  368.      * Se la connessione non e' presente, viene lanciata una eccezione che contiene il motivo della mancata connessione
  369.      * 
  370.      * @throws DriverException eccezione che contiene il motivo della mancata connessione
  371.      */
  372.     @Override
  373.     public void isAlive() throws CoreException{
  374.         if(!this.isAlive) {
  375.             return;
  376.         }
  377.         // Verifico la connessione
  378.         Connection con = null;
  379.         Statement stmtTest = null;
  380.         BasicConnectionResult cr = null;
  381.         try {
  382.             // Connessione al DB
  383.             cr = this.getConnection(null,"isAlive");
  384.             con = cr.getConnection();
  385.             
  386.             // test:
  387.             stmtTest = con.createStatement();
  388.             stmtTest.execute("SELECT * from db_info");
  389.         } catch (Exception e) {
  390.             throw new CoreException("Connessione al database '"+this.producerType+"' non disponibile: "+e.getMessage(),e);

  392.         }finally{
  393.             try{
  394.                 if(stmtTest!=null)
  395.                     stmtTest.close();
  396.             }catch(Exception e){
  397.                 // close
  398.             }
  399.             try{
  400.                 this.releaseConnection(cr, "isAlive");
  401.             }catch(Exception e){
  402.                 // close
  403.             }
  404.         }
  405.     }

  407. }

Created with JaCoCo 0.8.8.202204050719