DiagnosticDriver.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.diagnostica;

  25. import java.sql.Connection;
  26. import java.sql.DriverManager;
  27. import java.sql.PreparedStatement;
  28. import java.sql.ResultSet;
  29. import java.sql.SQLException;
  30. import java.util.ArrayList;
  31. import java.util.List;
  32. import java.util.Properties;

  34. import javax.sql.DataSource;

  36. import org.openspcoop2.protocol.basic.BasicComponentFactory;
  37. import org.openspcoop2.protocol.basic.Costanti;
  38. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  39. import org.openspcoop2.protocol.sdk.ProtocolException;
  40. import org.openspcoop2.protocol.sdk.diagnostica.DriverMsgDiagnosticiException;
  41. import org.openspcoop2.protocol.sdk.diagnostica.DriverMsgDiagnosticiNotFoundException;
  42. import org.openspcoop2.protocol.sdk.diagnostica.FiltroRicercaDiagnostici;
  43. import org.openspcoop2.protocol.sdk.diagnostica.FiltroRicercaDiagnosticiConPaginazione;
  44. import org.openspcoop2.protocol.sdk.diagnostica.IDiagnosticDriver;
  45. import org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico;
  46. import org.openspcoop2.protocol.sdk.tracciamento.DriverTracciamentoException;
  47. import org.openspcoop2.utils.LoggerWrapperFactory;
  48. import org.openspcoop2.utils.StringWrapper;
  49. import org.openspcoop2.utils.TipiDatabase;
  50. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  51. import org.openspcoop2.utils.resources.GestoreJNDI;
  52. import org.openspcoop2.utils.sql.ISQLQueryObject;
  53. import org.slf4j.Logger;

  55. /**
  56.  * Interfaccia di ricerca dei messaggi diagnostici
  57.  *
  58.  * @author Stefano Corallo (corallo@link.it)
  59.  * @author $Author$
  60.  * @version $Rev$, $Date$
  61.  */
  62. public class DiagnosticDriver extends BasicComponentFactory implements IDiagnosticDriver {
  63.     /** 
  64.      * DataSource
  65.      */
  66.     DataSource datasource = null;
  67.     /**
  68.      * SQLQueryObject
  69.      */
  70.     String tipoDatabase = null;
  71.     
  72.     Connection con = null;
  73.     boolean connectionOpenViaJDBCInCostructor = false;
  74.         
  75.     public DiagnosticDriver(IProtocolFactory<?> factory) throws ProtocolException{
  76.         super(factory);
  77.     }
  78.     
  79.     private static final String QUERY_PREFIX = "Query : ";
  80.     private static final String ROWS_SUFFIX = " rows";

  82.     
  83.     public static final String IDDIAGNOSTICI = "@@@@@-----@@@@-----IDDIAGNOSTICI-DB----@@@@@-----@@@@";
  84.     
  85.     
  86.     /**
  87.      * Properties per campi aggiuntivi
  88.      */
  89.     private List<String> propertiesMsgDiagnostici;
  90.     public void setPropertiesMsgDiagnostici(List<String> properties) {
  91.         this.propertiesMsgDiagnostici = properties;
  92.     }   
  93.     
  94.     
  95.     
  96.     
  97.     public void init(String nomeDataSource, String tipoDatabase, Properties jndiProperties) throws DriverMsgDiagnosticiException {
  98.         init(nomeDataSource,tipoDatabase,jndiProperties,null);
  99.     }
  100.     
  101.     public void init(String nomeDataSource, String tipoDatabase, Properties jndiProperties, Logger log) throws DriverMsgDiagnosticiException {
  102.         // Logger
  103.         try {
  104.             if(log==null)
  105.                 this.log = LoggerWrapperFactory.getLogger(Costanti.LOGANALIZER_DRIVER_DB_LOGGER);
  106.             else
  107.                 this.log = log;
  108.         } catch (Exception e) {
  109.             throw new DriverMsgDiagnosticiException("Errore durante l'inizializzazione del logger (datasource params): "+e.getMessage(),e);
  110.         }

  112.         // Datasource
  113.         try {
  114.             this.log.info("Inizializzo DriverLogAnalyzer...");
  115.             GestoreJNDI gestoreJNDI = new GestoreJNDI(jndiProperties);
  116.             this.datasource = (DataSource) gestoreJNDI.lookup(nomeDataSource);
  117.             if (this.datasource == null)
  118.                 throw new DriverMsgDiagnosticiException ("datasource is null");

  120.             this.log.info("Inizializzo DriverLogAnalyzer terminata.");
  121.         } catch (Exception e) {
  122.             this.logError("Errore durante la ricerca del datasource (datasource params): "+e.getMessage(),e);
  123.             throw new DriverMsgDiagnosticiException("Errore durante la ricerca del datasource (datasource params): "+e.getMessage(),e);
  124.         }

  126.         // ISQLQueryObject
  127.         try {
  128.             this.log.info("Inizializzo ISQLQueryObject (datasource params)");
  129.             if (TipiDatabase.isAMember(tipoDatabase)) {
  130.                 this.tipoDatabase = tipoDatabase;               
  131.             } else {
  132.                 throw new DriverMsgDiagnosticiException("Tipo database non gestito (datasource params)");
  133.             }
  134.             this.log.info("Inizializzo ISQLQueryObject terminata (datasource params)");

  136.         } catch (Exception e) {
  137.             this.logError("Errore durante la ricerca del SQLQueryObject (datasource params): "+e.getMessage(),e);
  138.             throw new DriverMsgDiagnosticiException("Errore durante la ricerca del SQLQueryObject (datasource params): "+e.getMessage(),e);
  139.         }
  140.     }
  141.     
  142.     public void init(DataSource dataSourceObject, String tipoDatabase) throws DriverMsgDiagnosticiException {
  143.         init(dataSourceObject,tipoDatabase,null);
  144.     }
  145.         
  146.     public void init(DataSource dataSourceObject, String tipoDatabase, Logger log) throws DriverMsgDiagnosticiException {
  147.         // Logger
  148.         try {
  149.             if(log==null)
  150.                 this.log = LoggerWrapperFactory.getLogger(Costanti.LOGANALIZER_DRIVER_DB_LOGGER);
  151.             else
  152.                 this.log = log;
  153.         } catch (Exception e) {
  154.             throw new DriverMsgDiagnosticiException("Errore durante l'inizializzazione del logger (datasource): "+e.getMessage(),e);
  155.         }

  157.         // Datasource
  158.         try {
  159.             this.datasource = dataSourceObject;
  160.             if (this.datasource == null)
  161.                 throw new DriverMsgDiagnosticiException ("datasource is null");
  162.         } catch (Exception e) {
  163.             this.logError("Errore durante l'assegnamento del datasource (datasource): "+e.getMessage(),e);
  164.             throw new DriverMsgDiagnosticiException("Errore durante l'assegnamento del datasource (datasource): "+e.getMessage(),e);
  165.         }

  167.         // ISQLQueryObject
  168.         try {
  169.             this.log.info("Inizializzo ISQLQueryObject (datasource)");
  170.             if (TipiDatabase.isAMember(tipoDatabase)) {
  171.                 this.tipoDatabase = tipoDatabase;               
  172.             } else {
  173.                 throw new DriverMsgDiagnosticiException("Tipo database non gestito (datasource)");
  174.             }
  175.             this.log.info("Inizializzo ISQLQueryObject terminata (datasource)");

  177.         } catch (Exception e) {
  178.             this.logError("Errore durante la ricerca del SQLQueryObject (datasource): "+e.getMessage(),e);
  179.             throw new DriverMsgDiagnosticiException("Errore durante la ricerca del SQLQueryObject (datasource): "+e.getMessage(),e);
  180.         }
  181.     }
  182.     
  183.     public void init(Connection connection, String tipoDatabase, Logger log) throws DriverMsgDiagnosticiException {
  184.         // Logger
  185.         try {
  186.             this.log = log;
  187.         } catch (Exception e) {
  188.             throw new DriverMsgDiagnosticiException("Errore durante l'inizializzazione del logger (connection): "+e.getMessage(),e);
  189.         }

  191.         // connection
  192.         this.con = connection;
  193.         
  194.         // ISQLQueryObject
  195.         try {
  196.             this.log.info("Inizializzo ISQLQueryObject (connection)");
  197.             if (TipiDatabase.isAMember(tipoDatabase)) {
  198.                 this.tipoDatabase = tipoDatabase;               
  199.             } else {
  200.                 throw new DriverMsgDiagnosticiException("Tipo database non gestito (connection)");
  201.             }
  202.             this.log.info("Inizializzo ISQLQueryObject terminata (connection)");

  204.         } catch (Exception e) {
  205.             this.logError("Errore durante la ricerca del SQLQueryObject (connection): "+e.getMessage(),e);
  206.             throw new DriverMsgDiagnosticiException("Errore durante la ricerca del SQLQueryObject (connection): "+e.getMessage(),e);
  207.         }
  208.     }
  209.     
  210.     public void init(String urlJDBC,String driverJDBC,
  211.             String username,String password, String tipoDatabase, Logger log) throws DriverMsgDiagnosticiException {
  212.         // Logger
  213.         try {
  214.             this.log = log;
  215.         } catch (Exception e) {
  216.             throw new DriverMsgDiagnosticiException("Errore durante l'inizializzazione del logger (connectionUrl params): "+e.getMessage(),e);
  217.         }

  219.         // connection
  220.         try {
  221.             Class.forName(driverJDBC);
  222.             
  223.             if(username!=null){
  224.                 this.con = DriverManager.getConnection(urlJDBC,username,password);
  225.             }else{
  226.                 this.con = DriverManager.getConnection(urlJDBC);
  227.             }
  228.             this.connectionOpenViaJDBCInCostructor = true;
  229.             
  230.         } catch (Exception e) {
  231.             this.logError("Errore durante l'inizializzazione della connessione (connectionUrl params): "+e.getMessage(),e);
  232.             throw new DriverMsgDiagnosticiException("Errore durante l'inizializzazione della connessione (connectionUrl params): "+e.getMessage(),e);
  233.         }
  234.                 
  235.         // ISQLQueryObject
  236.         try {
  237.             this.log.info("Inizializzo ISQLQueryObject (connectionUrl params)");
  238.             if (TipiDatabase.isAMember(tipoDatabase)) {
  239.                 this.tipoDatabase = tipoDatabase;               
  240.             } else {
  241.                 throw new DriverMsgDiagnosticiException("Tipo database non gestito (connectionUrl params)");
  242.             }
  243.             this.log.info("Inizializzo ISQLQueryObject terminata (connectionUrl params)");

  245.         } catch (Exception e) {
  246.             this.logError("Errore durante la ricerca del SQLQueryObject (connectionUrl params): "+e.getMessage(),e);
  247.             throw new DriverMsgDiagnosticiException("Errore durante la ricerca del SQLQueryObject (connectionUrl params): "+e.getMessage(),e);
  248.         }
  249.     }

  251.     
  252.     
  253.     
  254.     
  255.     
  256.     
  257.     
  258.     
  259.     /* *********** ACCESSI TRAMITE RICERCHE (DIAGNOSTICI) ******* */
  260.     
  261.     /**
  262.      * Si occupa di ritornare il numero di diagnostici che rispettano il filtro di ricerca
  263.      *
  264.      * @param filtro Filtro di ricerca
  265.      * @return numero di diagnostici che rispettano il filtro di ricerca
  266.      * 
  267.      */
  268.     @Override
  269.     public int countMessaggiDiagnostici(FiltroRicercaDiagnostici filtro) throws DriverMsgDiagnosticiException{
  270.         PreparedStatement stmt = null;
  271.         ResultSet rs=null;
  272.         Connection connectionDB = null;
  273.         boolean closeConnection = true;
  274.         ISQLQueryObject sqlObj =  null;
  275.         int countDiagnostici = 0;
  276.         try{
  277.             if(this.con!=null){
  278.                 connectionDB=this.con;
  279.                 closeConnection=false;
  280.             }else{
  281.                 connectionDB = this.datasource.getConnection();
  282.             }
  283.             checkConnection(connectionDB);

  285.             sqlObj = DiagnosticDriverUtilities.createSQLQueryObj_countMessaggiDiagnostici(filtro, this.tipoDatabase);
  286.             
  287.             StringWrapper sqlDebug = new StringWrapper(sqlObj.createSQLQuery());
  288.             DiagnosticDriverUtilities.setValues_countMessaggiDiagnostici(filtro, sqlDebug, 1);
  289.             this.logDebug(QUERY_PREFIX+sqlDebug);
  290.             
  291.             String sql = sqlObj.createSQLQuery();
  292.             stmt=connectionDB.prepareStatement(sql);
  293.             DiagnosticDriverUtilities.setValues_countMessaggiDiagnostici(filtro, stmt, 1);

  295.             rs=stmt.executeQuery();
  296.             if(rs.next()){
  297.                 
  298.                 countDiagnostici = rs.getInt("countMsgDiagnostici");
  299.                 
  300.             }
  301.             
  302.             this.logDebug("Query found "+countDiagnostici+ROWS_SUFFIX);
  303.             
  304.             return countDiagnostici;
  305.             
  306.         }catch (DriverMsgDiagnosticiException e) {
  307.             throw e;
  308.         }catch (Exception e) {
  309.             throw new DriverMsgDiagnosticiException(e);
  310.         }finally{
  311.             JDBCUtilities.closeResources(rs, stmt);
  312.             if(closeConnection){
  313.                 try{
  314.                     JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), connectionDB, BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  315.                 }catch (Exception e) {
  316.                     // ignore
  317.                 }
  318.             }
  319.         }
  320.     }
  321.     
  322.     /**
  323.      * Si occupa di ritornare i diagnostici che rispettano il filtro di ricerca
  324.      *
  325.      * @param filtro Filtro di ricerca
  326.      * @return diagnostici che rispettano il filtro di ricerca
  327.      * 
  328.      */
  329.     @Override
  330.     public List<MsgDiagnostico> getMessaggiDiagnostici(FiltroRicercaDiagnosticiConPaginazione filtro)  
  331.         throws DriverMsgDiagnosticiException, DriverMsgDiagnosticiNotFoundException{
  332.         PreparedStatement stmt = null;
  333.         ResultSet rs=null;
  334.         Connection connectionDB = null;
  335.         boolean closeConnection = true;
  336.         ISQLQueryObject sqlObj =  null;
  337.         try{
  338.             ArrayList<MsgDiagnostico> listaMSGDiagnostici = new ArrayList<>();
  339.             if(this.con!=null){
  340.                 connectionDB=this.con;
  341.                 closeConnection=false;
  342.             }else{
  343.                 connectionDB = this.datasource.getConnection();
  344.             }
  345.             checkConnection(connectionDB);
  346.             
  347.             sqlObj = DiagnosticDriverUtilities.createSQLQueryObj_searchMessaggiDiagnostici(filtro, this.tipoDatabase);
  348.             
  349.             StringWrapper sqlDebug = new StringWrapper(sqlObj.createSQLQuery());
  350.             DiagnosticDriverUtilities.setValues_searchMessaggiDiagnostici(filtro, sqlDebug, 1);
  351.             this.logDebug(QUERY_PREFIX+sqlDebug);
  352.             
  353.             String sql = sqlObj.createSQLQuery();
  354.             stmt=connectionDB.prepareStatement(sql);
  355.             DiagnosticDriverUtilities.setValues_searchMessaggiDiagnostici(filtro, stmt, 1);

  357.             rs=stmt.executeQuery();
  358.             while(rs.next()){
  359.                 
  360.                 long idMsgDiagnostico = rs.getLong("idMsgDiagnostico");
  361.                 MsgDiagnostico msgDiag = 
  362.                     DiagnosticDriverUtilities.getMsgDiagnostico(connectionDB, this.tipoDatabase, 
  363.                             this.log, idMsgDiagnostico, this.propertiesMsgDiagnostici);
  364.                 listaMSGDiagnostici.add(msgDiag);
  365.             }
  366.             rs.close();
  367.             stmt.close();
  368.             
  369.             this.logDebug("Query found "+listaMSGDiagnostici.size()+ROWS_SUFFIX);
  370.             
  371.             if(!listaMSGDiagnostici.isEmpty())
  372.                 return listaMSGDiagnostici;
  373.             else
  374.                 throw new DriverMsgDiagnosticiNotFoundException("Non sono stati trovati diagnostici che rispettano il filtro impostato");
  375.             
  376.         }catch (DriverMsgDiagnosticiNotFoundException | DriverMsgDiagnosticiException e) {
  377.             throw e;
  378.         }catch (Exception e) {
  379.             throw new DriverMsgDiagnosticiException(e);
  380.         }finally{
  381.             JDBCUtilities.closeResources(rs, stmt);
  382.             if(closeConnection){
  383.                 try{
  384.                     JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), connectionDB, BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  385.                 }catch (Exception e) {
  386.                     // ignore
  387.                 }
  388.             }
  389.         }
  390.     }
  391.     
  392.     
  393.     /**
  394.      * Si occupa di eliminare i diagnostici che rispettano il filtro di ricerca
  395.      * 
  396.      * @param filter Filtro di ricerca
  397.      * @return numero di diagnostici eliminati
  398.      * @throws DriverTracciamentoException
  399.      */
  400.     @Override
  401.     public int deleteMessaggiDiagnostici(FiltroRicercaDiagnostici filter) throws DriverMsgDiagnosticiException{
  402.         PreparedStatement stmt = null;
  403.         int deleted = 0; 
  404.         Connection connectionDB = null;
  405.         boolean closeConnection = true;
  406.         ISQLQueryObject sqlObj =  null;
  407.         try{
  408.             if(this.con!=null){
  409.                 connectionDB=this.con;
  410.                 closeConnection=false;
  411.             }else{
  412.                 connectionDB = this.datasource.getConnection();
  413.             }
  414.             checkConnection(connectionDB);
  415.             
  416.             sqlObj = DiagnosticDriverUtilities.createSQLQueryObj_deleteMessaggiDiagnostici(filter, this.tipoDatabase);
  417.             
  418.             StringWrapper sqlDebug = new StringWrapper(sqlObj.createSQLDelete());
  419.             DiagnosticDriverUtilities.setValues_deleteMessaggiDiagnostici(filter, sqlDebug, 1);
  420.             this.logDebug(QUERY_PREFIX+sqlDebug);
  421.             
  422.             String sql = sqlObj.createSQLDelete();
  423.             stmt=connectionDB.prepareStatement(sql);
  424.             DiagnosticDriverUtilities.setValues_deleteMessaggiDiagnostici(filter, stmt, 1);
  425.             
  426.             deleted = stmt.executeUpdate();     
  427.             
  428.             stmt.close();
  429.             
  430.             this.logDebug("Deleted "+deleted+ROWS_SUFFIX);
  431.             
  432.             return deleted;
  433.             
  434.         }catch (DriverMsgDiagnosticiException e) {
  435.             throw e;
  436.         }catch (Exception e) {
  437.             throw new DriverMsgDiagnosticiException(e);
  438.         }finally{
  439.             JDBCUtilities.closeResources(stmt);
  440.             if(closeConnection){
  441.                 try{
  442.                     JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), connectionDB, BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  443.                 }catch (Exception e) {
  444.                     // ignore
  445.                 }
  446.             }
  447.         }
  448.     }
  449.     
  450.     
  451.     
  452.     
  453.     
  454.     
  455.     
  456.     
  457.     
  458.     
  459.     
  460.     
  461.     
  462.     /* ******* RISORSE INTERNE ********** */
  463.     
  464.     @Override
  465.     public void close() throws DriverMsgDiagnosticiException {
  466.         try{
  467.             if(this.connectionOpenViaJDBCInCostructor &&
  468.                 this.con!=null && !this.con.isClosed()){
  469.                 JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), this.con, BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  470.             }
  471.         }catch(Exception e){
  472.             throw new DriverMsgDiagnosticiException(e.getMessage(),e);
  473.         }
  474.     }   
  475.     
  476.     
  477.     
  478.     
  479.     
  480.     
  481.     
  482.     
  483.     
  484.     
  485.     

  487.     
  488.     
  489.     
  490.     /* ------------- UTILITY INTERNE -------------------------- */

  492.     private void checkConnection(Connection con) throws DriverMsgDiagnosticiException {
  493.         if(con==null &&
  494.             this.con==null) {
  495.             throw new DriverMsgDiagnosticiException("Connection non ottenuta dal datasource["+this.datasource+"]");
  496.         }
  497.     }
  498.     
  499.     /**
  500.      * Viene chiamato in causa per ottenere una connessione al DB
  501.      */
  502.     public java.sql.Connection getConnection() {
  503.         if (this.datasource == null) {
  504.             return null;
  505.         }

  507.         Connection connectionDB = null;
  508.         try {
  509.             connectionDB = this.datasource.getConnection();
  510.         } catch (Exception e) {
  511.             return null;
  512.         }

  514.         return connectionDB;
  515.     }

  517.     /**
  518.      * Viene chiamato in causa per rilasciare una connessione al DB, effettuando
  519.      * precedentemente un commit
  520.      * 
  521.      * @param connectionDB
  522.      *            Connessione da rilasciare.
  523.      */
  524.     public void releaseConnection(java.sql.Connection connectionDB) {
  525.         try {
  526.             JDBCUtilities.closeConnection(BasicComponentFactory.getCheckLogger(), connectionDB, BasicComponentFactory.isCheckAutocommit(), BasicComponentFactory.isCheckIsClosed());
  527.         } catch (SQLException e) {
  528.             // ignore
  529.         }
  530.     }

  532.     /**
  533.      * Viene chiamato in causa per ottenere il tipoDatabase
  534.      */
  535.     public String getTipoDatabase() {
  536.         return this.tipoDatabase;
  537.     }

  539. }

Created with JaCoCo 0.8.8.202204050719