FiltroDuplicati.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.  */
  20. package org.openspcoop2.pdd.core.transazioni;

  22. import java.sql.Connection;
  23. import java.sql.PreparedStatement;
  24. import java.sql.ResultSet;
  25. import java.sql.Timestamp;
  26. import java.text.SimpleDateFormat;

  28. import org.slf4j.Logger;
  29. import org.openspcoop2.core.constants.CostantiDB;
  30. import org.openspcoop2.core.constants.TipoPdD;
  31. import org.openspcoop2.core.transazioni.Transazione;
  32. import org.openspcoop2.core.transazioni.dao.jdbc.converter.TransazioneFieldConverter;
  33. import org.openspcoop2.pdd.config.DBTransazioniManager;
  34. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  35. import org.openspcoop2.pdd.config.Resource;
  36. import org.openspcoop2.pdd.core.PdDContext;
  37. import org.openspcoop2.pdd.core.state.OpenSPCoopState;
  38. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  39. import org.openspcoop2.protocol.engine.driver.IFiltroDuplicati;
  40. import org.openspcoop2.protocol.sdk.Busta;
  41. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  42. import org.openspcoop2.protocol.sdk.ProtocolException;
  43. import org.openspcoop2.protocol.sdk.builder.IBustaBuilder;
  44. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  45. import org.openspcoop2.utils.date.DateManager;
  46. import org.openspcoop2.utils.date.DateUtils;
  47. import org.openspcoop2.utils.sql.ISQLQueryObject;
  48. import org.openspcoop2.utils.sql.SQLObjectFactory;

  50. /**     
  51.  * FiltroDuplicati
  52.  *
  53.  * @author Poli Andrea (poli@link.it)
  54.  * @author $Author$
  55.  * @version $Rev$, $Date$
  56.  */
  57. public class FiltroDuplicati implements IFiltroDuplicati {

  59.     private OpenSPCoop2Properties openspcoop2Properties;
  60.     
  61.     private String idTransazione = null;
  62.     private RequestInfo requestInfo = null;
  63.     
  64.     private org.openspcoop2.protocol.engine.driver.FiltroDuplicati filtroDuplicatiProtocol;
  65.         
  66.     private OpenSPCoopState openspcoop2State = null;
  67.     private Boolean initDsResource = null;
  68.     private Connection connection = null;
  69.     private boolean isDirectConnection = false;
  70.     @SuppressWarnings("unused")
  71.     private String modeGetConnection = null;
  72.     private boolean releaseRuntimeResourceBeforeCheck = false;
  73.     private String tipoDatabaseRuntime = null; 
  74.     private Logger log = null;
  75.     private Logger logSql = null;
  76.     private boolean debug = false;
  77.     
  78.     private TransazioneFieldConverter transazioneFieldConverter = null;
  79.     private String nomeTabellaTransazioni = null;

  81.     private String colonna_pdd_ruolo = null;
  82.     
  83.     private String colonna_duplicati_richiesta = null;
  84.     private String colonna_data_id_msg_richiesta = null;
  85.     private String colonna_id_messaggio_richiesta = null;

  87.     private String colonna_duplicati_risposta = null;
  88.     private String colonna_data_id_msg_risposta = null;
  89.     private String colonna_id_messaggio_risposta = null;
  90.     
  91.     private boolean useTransactionIdForTest = false; // solo per test
  92.     public boolean isUseTransactionIdForTest() {
  93.         return this.useTransactionIdForTest;
  94.     }
  95.     public void setUseTransactionIdForTest(boolean useTransactionIdForTest) {
  96.         this.useTransactionIdForTest = useTransactionIdForTest;
  97.     }

  99.     private static final String ID_MODULO = "FiltroDuplicati";
  100.     

  102.     @Override
  103.     public void init(Object context) throws ProtocolException{
  104.         
  105.         this.openspcoop2Properties = OpenSPCoop2Properties.getInstance();
  106.         
  107.         if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled() == false) {
  108.             this.filtroDuplicatiProtocol = new org.openspcoop2.protocol.engine.driver.FiltroDuplicati();
  109.             this.filtroDuplicatiProtocol.init(context);
  110.         }
  111.         else {
  112.             PdDContext pddContext = (PdDContext)context;
  113.             if(pddContext==null) {
  114.                 throw new ProtocolException("PdDContext non fornito");
  115.             }
  116.             this.idTransazione = (String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  117.             if(this.idTransazione==null){
  118.                 throw new ProtocolException("Id di transazione non fornito");
  119.             }
  120.             
  121.             if(pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  122.                 this.requestInfo = (RequestInfo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  123.             }
  124.             
  125.             if(this.initDsResource==null && this.connection==null){
  126.                 this.init((PdDContext)context);
  127.             }
  128.         }
  129.         
  130.     }
  131.     
  132.     @Override
  133.     public boolean releaseRuntimeResourceBeforeCheck() {
  134.         return this.releaseRuntimeResourceBeforeCheck;
  135.     }
  136.     
  137.     @Override
  138.     public boolean isDuplicata(IProtocolFactory<?> protocolFactory, String idBustaParam) throws ProtocolException {
  139.         
  140.         String idBusta = this.useTransactionIdForTest ? this.idTransazione : idBustaParam;
  141.                 
  142.         long timeStart = -1;
  143.         TransazioniFiltroDuplicatiProcessTimes times = null;
  144.         try {
  145.             if(this.openspcoop2Properties.isTransazioniRegistrazioneSlowLog()) {
  146.                 timeStart = DateManager.getTimeMillis();
  147.                 times = new TransazioniFiltroDuplicatiProcessTimes();
  148.             }
  149.         
  150.             if(this.filtroDuplicatiProtocol!=null) {
  151.                 return this.filtroDuplicatiProtocol.isDuplicata(protocolFactory, idBusta);
  152.             }
  153.             
  154.             //System.out.println("@@IS_DUPLICATA ["+idBusta+"] idTransaction("+this.idTransazione+") (useTransactionIdForTest:"+this.useTransactionIdForTest+") ...");
  155.             
  156.             // E' duplicata se esiste nel contesto una transazione con tale idBusta 
  157.             if(TransactionContext.containsIdentificativoProtocollo(idBusta)){
  158.                 //System.out.println("@@IS_DUPLICATA ["+idBusta+"] TRUE (CONTEXT)");
  159.                 try{
  160.                     TransactionContext.getTransaction(this.idTransazione).addIdProtocolloDuplicato(idBusta);
  161.                 }catch(Exception e){
  162.                     throw new ProtocolException(e);
  163.                 }
  164.                 return true;
  165.             }
  166.             
  167.             // oppure se esiste una transazione registrata con tale idBusta sul database (Richiesta o Risposta).
  168.             //System.out.println("@@IS_DUPLICATA ["+idBusta+"] READ FROM DB");
  169.             if(esisteTransazione(protocolFactory,idBusta,idBusta,times)){
  170.                 //System.out.println("@@IS_DUPLICATA ["+idBusta+"] TRUE (DATABASE)");
  171.                 try{
  172.                     TransactionContext.getTransaction(this.idTransazione).addIdProtocolloDuplicato(idBusta);
  173.                 }catch(Exception e){
  174.                     throw new ProtocolException(e);
  175.                 }
  176.                 return true;
  177.             }
  178.             
  179.             // Se non esiste registro nel contesto questa transazione.
  180.             // Comunque OpenSPCoop se torno false, procedera a chiamare registraBusta, il quale metodo non fara' nulla (vedi implementazione sotto stante)
  181.             // Il metodo di registrazione dell'identificativo busta viene acceduto tramite un semaforo e controlla che non sia possibile registrare due identificativi busta.
  182.             // Tale implementazione garantisce che nel contesto puo' esistere solo un idBusta, e tale id viene eliminato SOLO dopo 
  183.             // aver salvato la transazione nel database (vedi implementazione PostOutResponseHandler, metodo removeIdentificativoProtocollo)
  184.             // Se dopo aver eliminato dal contesto l'id, arriva una nuova busta con stesso id, questo metodo la trova nella tabelle delle transazioni 
  185.             // e quindi ritornera' immediatamente l'informazione di busta duplicata.
  186.             try{
  187.                 //System.out.println("@@IS_DUPLICATA ["+idBusta+"] FALSE ....");
  188.                 TransactionContext.registraIdentificativoProtocollo(idBusta, this.idTransazione);
  189.                 //System.out.println("@@IS_DUPLICATA ["+idBusta+"] FALSE REGISTRATA");
  190.             }catch(Exception e){
  191.                 if(e.getMessage()!=null && "DUPLICATA".equals(e.getMessage())){
  192.                     //System.out.println("@@IS_DUPLICATA ["+idBusta+"] TRUE (ERRORE ECCEZIONE)");
  193.                     try{
  194.                         TransactionContext.getTransaction(this.idTransazione).addIdProtocolloDuplicato(idBusta);
  195.                     }catch(Exception eSetDuplicata){
  196.                         throw new ProtocolException(eSetDuplicata);
  197.                     }
  198.                     return true;
  199.                 }else{
  200.                     throw new ProtocolException(e);
  201.                 }
  202.             }
  203.             
  204.             //System.out.println("@@IS_DUPLICATA ["+idBusta+"] FALSE FINE");
  205.             return false;
  206.             
  207.         }finally {
  208.             if(this.openspcoop2Properties.isTransazioniRegistrazioneSlowLog()) {
  209.                 long timeEnd =  DateManager.getTimeMillis();
  210.                 long timeProcess = timeEnd-timeStart;
  211.                 if(timeProcess>=this.openspcoop2Properties.getTransazioniRegistrazioneSlowLogThresholdMs()) {
  212.                     StringBuilder sb = new StringBuilder();
  213.                     sb.append(timeProcess);
  214.                     if(this.idTransazione!=null) {
  215.                         sb.append(" <").append(this.idTransazione).append(">");
  216.                     }
  217.                     sb.append(" [isDuplicata]");
  218.                     sb.append(" ").append(idBusta);
  219.                     if(times!=null) {
  220.                         sb.append(" ").append(times.toString());
  221.                     }
  222.                     OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniSlowLog().info(sb.toString());
  223.                 }
  224.             }
  225.         }
  226.     }

  228.     @Override
  229.     public void incrementaNumeroDuplicati(IProtocolFactory<?> protocolFactory, String idBusta) throws ProtocolException {
  230.         
  231.         long timeStart = -1;
  232.         TransazioniFiltroDuplicatiProcessTimes times = null;
  233.         try {
  234.             if(this.openspcoop2Properties.isTransazioniRegistrazioneSlowLog()) {
  235.                 timeStart = DateManager.getTimeMillis();
  236.                 times = new TransazioniFiltroDuplicatiProcessTimes();
  237.             }
  238.         
  239.             if(this.filtroDuplicatiProtocol!=null) {
  240.                 this.filtroDuplicatiProtocol.incrementaNumeroDuplicati(protocolFactory, idBusta);
  241.                 return;
  242.             }
  243.             
  244.             //System.out.println("@@incrementaNumeroDuplicati ["+idBusta+"] ...");
  245.             
  246.             incrementDuplicatiTransazione(protocolFactory, idBusta, times);
  247.             
  248.             //System.out.println("@@incrementaNumeroDuplicati richiesta["+esisteRichiesta+"] risposta["+esisteRisposta+"] FINE");
  249.         }finally {
  250.             if(this.openspcoop2Properties.isTransazioniRegistrazioneSlowLog()) {
  251.                 long timeEnd =  DateManager.getTimeMillis();
  252.                 long timeProcess = timeEnd-timeStart;
  253.                 if(timeProcess>=this.openspcoop2Properties.getTransazioniRegistrazioneSlowLogThresholdMs()) {
  254.                     StringBuilder sb = new StringBuilder();
  255.                     sb.append(timeProcess);
  256.                     if(this.idTransazione!=null) {
  257.                         sb.append(" <").append(this.idTransazione).append(">");
  258.                     }
  259.                     sb.append(" [incrementaNumeroDuplicati]");
  260.                     sb.append(" ").append(idBusta);
  261.                     if(times!=null) {
  262.                         sb.append(" ").append(times.toString());
  263.                     }
  264.                     OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniSlowLog().info(sb.toString());
  265.                 }
  266.             }
  267.         }
  268.     }

  270.     @Override
  271.     public void registraBusta(IProtocolFactory<?> protocolFactory, Busta busta) throws ProtocolException {
  272.         
  273.         long timeStart = -1;
  274.         try {
  275.             if(this.openspcoop2Properties.isTransazioniRegistrazioneSlowLog()) {
  276.                 timeStart = DateManager.getTimeMillis();
  277.             }
  278.         
  279.             if(this.filtroDuplicatiProtocol!=null) {
  280.                 this.filtroDuplicatiProtocol.registraBusta(protocolFactory, busta);
  281.                 return;
  282.             }
  283.             
  284.             // Implementazione inserita in isDuplicata
  285.             //System.out.println("@@registraBusta ["+busta.getID()+"] NON IMPLEMENTATO");
  286.             
  287.         }finally {
  288.             if(this.openspcoop2Properties.isTransazioniRegistrazioneSlowLog()) {
  289.                 long timeEnd =  DateManager.getTimeMillis();
  290.                 long timeProcess = timeEnd-timeStart;
  291.                 if(timeProcess>=this.openspcoop2Properties.getTransazioniRegistrazioneSlowLogThresholdMs()) {
  292.                     StringBuilder sb = new StringBuilder();
  293.                     sb.append(timeProcess);
  294.                     if(this.idTransazione!=null) {
  295.                         sb.append(" <").append(this.idTransazione).append(">");
  296.                     }
  297.                     sb.append(" [registraBusta]");
  298.                     if(busta!=null) {
  299.                         sb.append(" ").append(busta.getID());
  300.                     }
  301.                     OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniSlowLog().info(sb.toString());
  302.                 }
  303.             }
  304.         }
  305.     }

  307.     
  308.     
  309.     /* **** METODI INTERNI **** */
  310.     
  311.     private synchronized void init(PdDContext pddContext) throws ProtocolException {

  313.         //if(this.dsRuntime==null && this.connection==null){
  314.         if(this.initDsResource==null && this.connection==null){
  315.             
  316.             try{
  317.                 // Debug
  318.                 this.debug = this.openspcoop2Properties.isTransazioniDebug();
  319.                 this.log = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioni(this.debug);
  320.                 this.logSql = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniSql(this.debug);
  321.             }catch(Exception e){
  322.                 throw new ProtocolException("Errore durante l'inizializzazione del logger: "+e.getMessage(),e);
  323.             }
  324.             
  325.             try{
  326.                 
  327.                 // TipoDatabase
  328.                 this.tipoDatabaseRuntime = this.openspcoop2Properties.getDatabaseType();
  329.                 if(this.tipoDatabaseRuntime==null){
  330.                     throw new Exception("Tipo Database non definito");
  331.                 }
  332.                 
  333.                 // DB Resource
  334.                 Object openspcoopstate = pddContext.getObject(org.openspcoop2.core.constants.Costanti.OPENSPCOOP_STATE);
  335.                 if(openspcoopstate!=null) {
  336.                     this.openspcoop2State = (OpenSPCoopState) openspcoopstate;
  337.                 }
  338.                 if(this.openspcoop2State!=null && this.openspcoop2Properties.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection()
  339.                         && DBTransazioniManager.getInstance().useRuntimePdD() && !this.openspcoop2State.resourceReleased()){
  340.                     //System.out.println("[FILTRO] INIZIALIZZO CONNESSIONE");
  341.                     this.connection = this.openspcoop2State.getConnectionDB();
  342.                     //this.datasourceRuntime = "DirectConnection";
  343.                     this.modeGetConnection = "DirectConnection";
  344.                     this.isDirectConnection = true;
  345.                 }
  346.                 else{
  347.                     //System.out.println("[FILTRO] INIZIALIZZO DS");
  348. //                  this.datasourceRuntime = PddInterceptorConfig.getDataSource();
  349. //                  if(this.datasourceRuntime==null){
  350. //                      throw new Exception("Datasource non definito");
  351. //                  }
  352.                     this.initDsResource = true;
  353.                     this.modeGetConnection = "DatasourceRuntime";
  354.                     
  355.                     this.releaseRuntimeResourceBeforeCheck = true; // per evitare deadlock
  356.                     
  357.                     // Inizializzazione datasource
  358. //                  GestoreJNDI jndi = new GestoreJNDI();
  359. //                  this.dsRuntime = (DataSource) jndi.lookup(this.datasourceRuntime);
  360.                 }
  361.                                 
  362.                 //System.out.println("DS["+this.datasource+"] TIPODB["+this.tipoDatabase+"]");
  363.                                 
  364.                 this.transazioneFieldConverter = new TransazioneFieldConverter(this.tipoDatabaseRuntime);
  365.                 
  366.                 this.nomeTabellaTransazioni = this.transazioneFieldConverter.toTable(Transazione.model());
  367.                 
  368.                 this.colonna_pdd_ruolo = this.transazioneFieldConverter.toColumn(Transazione.model().PDD_RUOLO, false);
  369.                             
  370.                 this.colonna_duplicati_richiesta = this.transazioneFieldConverter.toColumn(Transazione.model().DUPLICATI_RICHIESTA, false);
  371.                 this.colonna_data_id_msg_richiesta = this.transazioneFieldConverter.toColumn(Transazione.model().DATA_ID_MSG_RICHIESTA, false);
  372.                 this.colonna_id_messaggio_richiesta = this.transazioneFieldConverter.toColumn(Transazione.model().ID_MESSAGGIO_RICHIESTA, false);
  373.                 
  374.                 this.colonna_duplicati_risposta = this.transazioneFieldConverter.toColumn(Transazione.model().DUPLICATI_RISPOSTA, false);
  375.                 this.colonna_data_id_msg_risposta = this.transazioneFieldConverter.toColumn(Transazione.model().DATA_ID_MSG_RISPOSTA, false);
  376.                 this.colonna_id_messaggio_risposta = this.transazioneFieldConverter.toColumn(Transazione.model().ID_MESSAGGIO_RISPOSTA, false);
  377.                 
  378.             }catch(Exception e){
  379.                 throw new ProtocolException("Errore durante l'inizializzazione dell'appender: "+e.getMessage(),e);
  380.             }
  381.         }
  382.         
  383.     }
  384.     
  385.     
  386.     
  387.     private boolean esisteTransazione(IProtocolFactory<?> protocolFactory, String idBustaRichiesta,String idBustaRisposta,
  388.             TransazioniFiltroDuplicatiProcessTimes times) throws ProtocolException {
  389.         Connection con = null;
  390.         DBTransazioniManager dbManager = null;
  391.         Resource r = null;
  392.         String idModulo = ID_MODULO+".esisteTransazione"; //_"+idBustaRichiesta+"/"+idBustaRisposta;
  393.         try{
  394.             
  395.             IBustaBuilder<?> protocolBustaBuilder = null;
  396.             if(this.openspcoop2State!=null) {
  397.                 if(idBustaRichiesta!=null) {
  398.                     protocolBustaBuilder = protocolFactory.createBustaBuilder(this.openspcoop2State.getStatoRichiesta());
  399.                 }
  400.                 else {
  401.                     protocolBustaBuilder = protocolFactory.createBustaBuilder(this.openspcoop2State.getStatoRisposta());
  402.                 }
  403.             }
  404.             else {                  
  405.                 protocolBustaBuilder = protocolFactory.createBustaBuilder(null);
  406.             }
  407.             
  408.             if(idBustaRichiesta==null && idBustaRisposta==null){
  409.                 throw new ProtocolException("ID busta non forniti");
  410.             }
  411.             
  412.             long timeStart = -1;
  413.             try{
  414.                 if(times!=null) {
  415.                     timeStart = DateManager.getTimeMillis();
  416.                 }
  417.                 if(this.connection!=null){
  418.                     //System.out.println("[FILTRO] esisteTransazione idBustaRichiesta["+idBustaRichiesta+"] idBustaRisposta["+idBustaRisposta+"] BY CONNECTION");
  419.                     con = this.connection;
  420.                 }else{
  421.                     //System.out.println("[FILTRO] esisteTransazione idBustaRichiesta["+idBustaRichiesta+"] idBustaRisposta["+idBustaRisposta+"] BY DATASOURCE");
  422.                     dbManager = DBTransazioniManager.getInstance();
  423.                     r = dbManager.getResource(this.openspcoop2Properties.getIdentitaPortaDefault(protocolFactory.getProtocol(), this.requestInfo), idModulo, this.idTransazione);
  424.                     if(r==null){
  425.                         throw new Exception("Risorsa al database non disponibile");
  426.                     }
  427.                     con = (Connection) r.getResource();
  428.                 }
  429.                 if(con==null){
  430.                     throw new Exception("Connection is null");
  431.                 }
  432.             }finally {  
  433.                 if(times!=null) {
  434.                     long timeEnd =  DateManager.getTimeMillis();
  435.                     long timeProcess = timeEnd-timeStart;
  436.                     times.getConnection = timeProcess;
  437.                 }
  438.             }
  439.             
  440.             return esisteTransazione_query(protocolFactory, idBustaRichiesta, idBustaRisposta,
  441.                     con, protocolBustaBuilder, times);
  442.             
  443.         }catch(Exception e){
  444.             throw new ProtocolException(e);
  445.         }
  446.         finally{
  447.             if(this.isDirectConnection==false){
  448.                 try{
  449.                     if(r!=null)
  450.                         dbManager.releaseResource(this.openspcoop2Properties.getIdentitaPortaDefault(protocolFactory.getProtocol(), this.requestInfo), idModulo, r);
  451.                 }catch(Exception eClose){}
  452.             }
  453.         }
  454.         
  455.     }
  456.     
  457.     private void incrementDuplicatiTransazione(IProtocolFactory<?> protocolFactory, String idBusta,
  458.             TransazioniFiltroDuplicatiProcessTimes times) throws ProtocolException {
  459.         Connection con = null;
  460.         DBTransazioniManager dbManager = null;
  461.         Resource r = null;
  462.         String idModulo = ID_MODULO+".incrementDuplicatiTransazione"; //_"+idBustaRichiesta+"/"+idBustaRisposta;
  463.         try{
  464.             
  465.             IBustaBuilder<?> protocolBustaBuilder = null;
  466.             if(this.openspcoop2State!=null) {
  467.                 if(this.openspcoop2State.getStatoRichiesta()!=null) {
  468.                     protocolBustaBuilder = protocolFactory.createBustaBuilder(this.openspcoop2State.getStatoRichiesta());
  469.                 }
  470.                 else {
  471.                     protocolBustaBuilder = protocolFactory.createBustaBuilder(this.openspcoop2State.getStatoRisposta());
  472.                 }
  473.             }
  474.             else {                  
  475.                 protocolBustaBuilder = protocolFactory.createBustaBuilder(null);
  476.             }
  477.             
  478.             if(idBusta==null){
  479.                 throw new ProtocolException("ID busta non fornito");
  480.             }
  481.             
  482.             long timeStart = -1;
  483.             try{
  484.                 if(times!=null) {
  485.                     timeStart = DateManager.getTimeMillis();
  486.                 }
  487.                 if(this.connection!=null){
  488.                     //System.out.println("[FILTRO] esisteTransazione idBustaRichiesta["+idBustaRichiesta+"] idBustaRisposta["+idBustaRisposta+"] BY CONNECTION");
  489.                     con = this.connection;
  490.                 }else{
  491.                     //System.out.println("[FILTRO] esisteTransazione idBustaRichiesta["+idBustaRichiesta+"] idBustaRisposta["+idBustaRisposta+"] BY DATASOURCE");
  492.                     dbManager = DBTransazioniManager.getInstance();
  493.                     r = dbManager.getResource(this.openspcoop2Properties.getIdentitaPortaDefault(protocolFactory.getProtocol(), this.requestInfo), idModulo, this.idTransazione);
  494.                     if(r==null){
  495.                         throw new Exception("Risorsa al database non disponibile");
  496.                     }
  497.                     con = (Connection) r.getResource();
  498.                 }
  499.                 if(con==null){
  500.                     throw new Exception("Connection is null");
  501.                 }
  502.             }finally {  
  503.                 if(times!=null) {
  504.                     long timeEnd =  DateManager.getTimeMillis();
  505.                     long timeProcess = timeEnd-timeStart;
  506.                     times.getConnection = timeProcess;
  507.                 }
  508.             }
  509.             
  510.             
  511.             // Aggiorno numero duplicati per transazione che possiede tale idBusta (Richiesta o Risposta)
  512.             // Se non esiste una transazione sul database, devo attendere che questa compaia,
  513.             // significa che una precedente transazione con stesso idBusta e' ancora in gestione
  514.             
  515.             long timeRequest = -1;
  516.             long timeResponse = -1;
  517.             long timeSleep = -1;
  518.             boolean esisteRichiesta = false;
  519.             boolean esisteRisposta = false;
  520.             try{
  521.                 TransazioniFiltroDuplicatiProcessTimes checkRequest = null;
  522.                 TransazioniFiltroDuplicatiProcessTimes checkResponse = null;
  523.                 
  524.                 if(times!=null) {
  525.                     checkRequest = new TransazioniFiltroDuplicatiProcessTimes();
  526.                 }
  527.                 esisteRichiesta = esisteTransazione_query(protocolFactory,idBusta,null,con,protocolBustaBuilder,checkRequest);
  528.                 if(times!=null) {
  529.                     timeRequest=checkRequest.read;
  530.                 }
  531.                 
  532.                 if(!esisteRichiesta){
  533.                     if(times!=null) {
  534.                         checkResponse = new TransazioniFiltroDuplicatiProcessTimes();
  535.                     }
  536.                     esisteRisposta = esisteTransazione_query(protocolFactory,null,idBusta,con,protocolBustaBuilder,checkResponse);
  537.                     if(times!=null) {
  538.                         timeResponse=checkResponse.read;
  539.                     }
  540.                 }
  541.                 //System.out.println("@@incrementaNumeroDuplicati richiesta["+esisteRichiesta+"] risposta["+esisteRisposta+"] ...");
  542.                 
  543.                 int i=0;
  544.                 while(!esisteRichiesta && !esisteRisposta && i<60){
  545.                     //System.out.println("@@incrementaNumeroDuplicati WHILE richiesta["+esisteRichiesta+"] risposta["+esisteRisposta+"]  SLEEP ...");
  546.                     // ATTENDI
  547.                     org.openspcoop2.utils.Utilities.sleep(1000);
  548.                     if(timeSleep==-1) {
  549.                         timeSleep=1000;
  550.                     }else {
  551.                         timeSleep = timeSleep + 1000;
  552.                     }
  553.                     
  554.                     i++;
  555.                     
  556.                     if(times!=null) {
  557.                         checkRequest = new TransazioniFiltroDuplicatiProcessTimes();
  558.                     }
  559.                     esisteRichiesta = esisteTransazione_query(protocolFactory,idBusta,null,con,protocolBustaBuilder,checkRequest);
  560.                     if(times!=null) {
  561.                         timeRequest = timeRequest + checkRequest.read;
  562.                     }
  563.                     
  564.                     if(!esisteRichiesta){
  565.                         if(times!=null) {
  566.                             checkResponse = new TransazioniFiltroDuplicatiProcessTimes();
  567.                         }
  568.                         esisteRisposta = esisteTransazione_query(protocolFactory,null,idBusta,con,protocolBustaBuilder,checkResponse);
  569.                         if(times!=null) {
  570.                             timeResponse = timeResponse + checkResponse.read;
  571.                         }
  572.                     }
  573.                     //System.out.println("@@incrementaNumeroDuplicati WHILE richiesta["+esisteRichiesta+"] risposta["+esisteRisposta+"]  SLEEP FINE ...");
  574.                 }
  575.             }finally {  
  576.                 if(times!=null) {
  577.                     times.checkExistsRequest = timeRequest;
  578.                     times.checkExistsResponse = timeResponse;
  579.                     times.checkSleep = timeSleep;
  580.                 }
  581.             }
  582.             
  583.             if(esisteRichiesta){
  584.                 incrementDuplicatiTransazione(protocolFactory,true, idBusta,
  585.                         con, protocolBustaBuilder, times);
  586.             }
  587.             else if(esisteRisposta){
  588.                 incrementDuplicatiTransazione(protocolFactory,false, idBusta,
  589.                         con, protocolBustaBuilder, times);
  590.             }
  591.             else{
  592.                 throw new ProtocolException("Precedente transazione con solito idBusta risulta in gestione da oltre 60 secondi");
  593.             }
  594.             
  595.             
  596.         }catch(Exception e){
  597.             throw new ProtocolException(e);
  598.         }
  599.         finally{
  600.             if(this.isDirectConnection==false){
  601.                 try{
  602.                     if(r!=null)
  603.                         dbManager.releaseResource(this.openspcoop2Properties.getIdentitaPortaDefault(protocolFactory.getProtocol(), this.requestInfo), idModulo, r);
  604.                 }catch(Exception eClose){}
  605.             }
  606.         }
  607.         
  608.     }
  609.     
  610.     private boolean esisteTransazione_query(IProtocolFactory<?> protocolFactory, String idBustaRichiesta,String idBustaRisposta,
  611.             Connection con, IBustaBuilder<?> protocolBustaBuilder, TransazioniFiltroDuplicatiProcessTimes times) throws ProtocolException {
  612.         PreparedStatement pstmt = null;
  613.         ResultSet rs = null;
  614.         try{
  615.             
  616.             long timeStart = -1;
  617.             try{
  618.                 if(times!=null) {
  619.                     timeStart = DateManager.getTimeMillis();
  620.                 }
  621.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabaseRuntime);
  622.                 if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex()){
  623.                     if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  624.                         //System.out.println("ADD FORCE INDEX esisteTransazione INDEX2");
  625.                         sqlQueryObject.addSelectForceIndex(this.nomeTabellaTransazioni, CostantiDB.TABLE_TRANSAZIONI_INDEX_FILTRO_REQ_2);
  626.                         sqlQueryObject.addSelectForceIndex(this.nomeTabellaTransazioni, CostantiDB.TABLE_TRANSAZIONI_INDEX_FILTRO_RES_2);
  627.                     }else{
  628.                         //System.out.println("ADD FORCE INDEX esisteTransazione INDEX1");
  629.                         sqlQueryObject.addSelectForceIndex(this.nomeTabellaTransazioni, CostantiDB.TABLE_TRANSAZIONI_INDEX_FILTRO_REQ_1);
  630.                         sqlQueryObject.addSelectForceIndex(this.nomeTabellaTransazioni, CostantiDB.TABLE_TRANSAZIONI_INDEX_FILTRO_RES_1);
  631.                     }
  632.                 }/*else{
  633.                     System.out.println("NON USO FORCE INDEX esisteTransazione");
  634.                 }*/
  635.                 sqlQueryObject.addFromTable(this.nomeTabellaTransazioni);
  636.                 if(idBustaRichiesta!=null){
  637.                     // Solo una porta applicativa puo' ricevere una busta di richiesta (serve per evitare i problemi in caso di loopback)
  638.                     if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  639.                         sqlQueryObject.addWhereCondition(true,this.colonna_data_id_msg_richiesta+"=?",this.colonna_id_messaggio_richiesta+"=?",this.colonna_pdd_ruolo+"=?");    
  640.                     }
  641.                     else{
  642.                         sqlQueryObject.addWhereCondition(true,this.colonna_id_messaggio_richiesta+"=?",this.colonna_pdd_ruolo+"=?");    
  643.                     }
  644.                 }
  645.                 if(idBustaRisposta!=null){
  646.                      // Solo una porta delegata puo' ricevere una busta di risposta (serve per evitare i problemi in caso di loopback)
  647.                     if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  648.                         sqlQueryObject.addWhereCondition(true,this.colonna_data_id_msg_risposta+"=?",this.colonna_id_messaggio_risposta+"=?",this.colonna_pdd_ruolo+"=?");
  649.                     }
  650.                     else{
  651.                         sqlQueryObject.addWhereCondition(true,this.colonna_id_messaggio_risposta+"=?",this.colonna_pdd_ruolo+"=?"); 
  652.                     }
  653.                 }
  654.                 sqlQueryObject.setANDLogicOperator(false); // OR
  655.                 
  656.                 String sql = sqlQueryObject.createSQLQuery();
  657.                 pstmt = con.prepareStatement(sql);
  658.                 int index = 1;
  659.                 Timestamp t = null;
  660.                 if(idBustaRichiesta!=null){
  661.                     if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  662.                         t = DateUtility.getTimestampIntoIdProtocollo(this.log,protocolBustaBuilder,idBustaRichiesta);
  663.                         if(t==null && (!this.useTransactionIdForTest)){
  664.                             throw new Exception("Estrazione data dall'id busta ["+idBustaRichiesta+"] non riuscita");
  665.                         }
  666.                         pstmt.setTimestamp(index++, t);
  667.                     }
  668.                     pstmt.setString(index++, idBustaRichiesta);
  669.                     pstmt.setString(index++, TipoPdD.APPLICATIVA.getTipo());
  670.                 }
  671.                 if(idBustaRisposta!=null){
  672.                     if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  673.                         t = DateUtility.getTimestampIntoIdProtocollo(this.log,protocolBustaBuilder,idBustaRisposta);
  674.                         if(t==null && (!this.useTransactionIdForTest)){
  675.                             throw new Exception("Estrazione data dall'id busta ["+idBustaRisposta+"] non riuscita");
  676.                         }
  677.                         pstmt.setTimestamp(index++, t);
  678.                     }
  679.                     pstmt.setString(index++, idBustaRisposta);
  680.                     pstmt.setString(index++, TipoPdD.DELEGATA.getTipo());
  681.                 }
  682.                 
  683.                 if(this.debug){
  684.                     SimpleDateFormat dateformat = null;
  685.                     if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory) && t!=null){
  686.                         dateformat = DateUtils.getDefaultDateTimeFormatter("yyyy-MM-dd HH:mm");
  687.                     }
  688.                     if(idBustaRichiesta!=null){
  689.                         if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory) && dateformat!=null){
  690.                             sql = sql.replaceFirst("\\?", "'"+dateformat.format(t)+"'");
  691.                         }
  692.                         sql = sql.replaceFirst("\\?", "'"+idBustaRichiesta+"'");
  693.                         sql = sql.replaceFirst("\\?", "'"+TipoPdD.APPLICATIVA.getTipo()+"'");
  694.                     }
  695.                     if(idBustaRisposta!=null){
  696.                         if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory) && dateformat!=null){
  697.                             sql = sql.replaceFirst("\\?", "'"+dateformat.format(t)+"'");
  698.                         }
  699.                         sql = sql.replaceFirst("\\?", "'"+idBustaRisposta+"'");
  700.                         sql = sql.replaceFirst("\\?", "'"+TipoPdD.DELEGATA.getTipo()+"'");
  701.                     }
  702.                     this.logSql.debug("Eseguo query: "+sql);
  703.                 }
  704.                 //System.out.println("esisteTransazione SQL: "+sql);
  705.                 
  706.                 rs = pstmt.executeQuery();
  707.                 if(rs.next()){
  708.                     if(this.debug){
  709.                         this.logSql.debug("Risultato query: "+true);
  710.                     }
  711.                     return true;
  712.                 }else{
  713.                     if(this.debug){
  714.                         this.logSql.debug("Risultato query: "+false);
  715.                     }
  716.                     return false;
  717.                 }
  718.             }finally {  
  719.                 if(times!=null) {
  720.                     long timeEnd =  DateManager.getTimeMillis();
  721.                     long timeProcess = timeEnd-timeStart;
  722.                     times.read = timeProcess;
  723.                 }
  724.             }
  725.             
  726.         }catch(Exception e){
  727.             throw new ProtocolException(e);
  728.         }
  729.         finally{
  730.             try{
  731.                 if(rs!=null)
  732.                     rs.close();
  733.             }catch(Exception eClose){}
  734.             try{
  735.                 if(pstmt!=null)
  736.                     pstmt.close();
  737.             }catch(Exception eClose){
  738.                 // close
  739.             }
  740.         }
  741.         
  742.     }
  743.     
  744.     private void incrementDuplicatiTransazione(IProtocolFactory<?> protocolFactory, boolean richiesta,String idBusta,
  745.             Connection con, IBustaBuilder<?> protocolBustaBuilder, TransazioniFiltroDuplicatiProcessTimes times) throws ProtocolException {
  746.         PreparedStatement pstmt = null;
  747.         try{
  748.             
  749.             if(idBusta==null){
  750.                 throw new ProtocolException("ID busta non fornito");
  751.             }
  752.             
  753.             long timeStart = -1;
  754.             try{
  755.                 if(times!=null) {
  756.                     timeStart = DateManager.getTimeMillis();
  757.                 }
  758.             
  759.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabaseRuntime);
  760.                 if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex()){
  761.                     if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  762.                         //  System.out.println("ADD FORCE INDEX esisteTransazione INDEX1");
  763.                         sqlQueryObject.addSelectForceIndex(this.nomeTabellaTransazioni, CostantiDB.TABLE_TRANSAZIONI_INDEX_FILTRO_REQ_2);
  764.                         sqlQueryObject.addSelectForceIndex(this.nomeTabellaTransazioni, CostantiDB.TABLE_TRANSAZIONI_INDEX_FILTRO_RES_2);
  765.                     }else{
  766.                         //  System.out.println("ADD FORCE INDEX esisteTransazione INDEX2");
  767.                         sqlQueryObject.addSelectForceIndex(this.nomeTabellaTransazioni, CostantiDB.TABLE_TRANSAZIONI_INDEX_FILTRO_REQ_1);
  768.                         sqlQueryObject.addSelectForceIndex(this.nomeTabellaTransazioni, CostantiDB.TABLE_TRANSAZIONI_INDEX_FILTRO_RES_1);
  769.                     }
  770.                 }
  771.                 sqlQueryObject.addUpdateTable(this.nomeTabellaTransazioni);
  772.                 if(richiesta){
  773.                     sqlQueryObject.addUpdateField(this.colonna_duplicati_richiesta, this.colonna_duplicati_richiesta+"+1");
  774.                     if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  775.                         sqlQueryObject.addWhereCondition(this.colonna_data_id_msg_richiesta+"=?");
  776.                     }
  777.                     sqlQueryObject.addWhereCondition(this.colonna_id_messaggio_richiesta+"=?");
  778.                     sqlQueryObject.addWhereCondition(this.colonna_duplicati_richiesta+">=?");
  779.                     // Solo una porta applicativa puo' ricevere una busta di richiesta (serve per evitare i problemi in caso di loopback)
  780.                     sqlQueryObject.addWhereCondition(this.colonna_pdd_ruolo+"=?");  
  781.                 }
  782.                 else{
  783.                     sqlQueryObject.addUpdateField(this.colonna_duplicati_risposta, this.colonna_duplicati_risposta+"+1");
  784.                     if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  785.                         sqlQueryObject.addWhereCondition(this.colonna_data_id_msg_risposta+"=?");
  786.                     }
  787.                     sqlQueryObject.addWhereCondition(this.colonna_id_messaggio_risposta+"=?");
  788.                     sqlQueryObject.addWhereCondition(this.colonna_duplicati_risposta+">=?");
  789.                     // Solo una porta delegata puo' ricevere una busta di risposta (serve per evitare i problemi in caso di loopback)
  790.                     sqlQueryObject.addWhereCondition(this.colonna_pdd_ruolo+"=?");  
  791.                 }
  792.                 sqlQueryObject.setANDLogicOperator(true); 
  793.                 
  794.                 Timestamp timestampId = DateUtility.getTimestampIntoIdProtocollo(this.log,protocolBustaBuilder,idBusta);
  795.                 if(timestampId==null && this.openspcoop2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory) && (!this.useTransactionIdForTest)){
  796.                     throw new Exception("Estrazione data dall'id busta ["+idBusta+"] non riuscita");
  797.                 }
  798.                 
  799.                 String sql = sqlQueryObject.createSQLUpdate();
  800.                 //System.out.println("incrementDuplicatiTransazione SQL: "+sql);
  801.                 pstmt = con.prepareStatement(sql);
  802.                 int index = 1;
  803.                 if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  804.                     pstmt.setTimestamp(index++, timestampId);
  805.                 }
  806.                 pstmt.setString(index++, idBusta);
  807.                 pstmt.setInt(index++, 0);
  808.                 if(richiesta){
  809.                     pstmt.setString(index++, TipoPdD.APPLICATIVA.getTipo());
  810.                 }
  811.                 else {
  812.                     pstmt.setString(index++, TipoPdD.DELEGATA.getTipo());
  813.                 }
  814.                 
  815.                 if(this.debug){
  816.                     if(this.openspcoop2Properties.isTransazioniFiltroDuplicatiSaveDateEnabled(protocolFactory)){
  817.                         SimpleDateFormat dateformat = DateUtils.getDefaultDateTimeFormatter("yyyy-MM-dd HH:mm");
  818.                         sql = sql.replaceFirst("\\?", "'"+dateformat.format(timestampId)+"'");
  819.                     }
  820.                     if(idBusta!=null){
  821.                         sql = sql.replaceFirst("\\?", "'"+idBusta+"'");
  822.                     }
  823.                     sql = sql.replaceFirst("\\?", "0");
  824.                     if(richiesta){
  825.                         sql = sql.replaceFirst("\\?", "'"+TipoPdD.APPLICATIVA.getTipo()+"'");
  826.                     }
  827.                     else {
  828.                         sql = sql.replaceFirst("\\?", "'"+TipoPdD.DELEGATA.getTipo()+"'");
  829.                     }
  830.                     this.logSql.debug("Eseguo query: "+sql);
  831.                 }
  832.                 
  833.                 int righeModificate = pstmt.executeUpdate();
  834.                 if(this.debug){
  835.                     this.logSql.debug("ID["+idBusta+"] richiesta["+richiesta+"] modificate righe: "+righeModificate);
  836.                 }
  837.                 
  838.             }finally {  
  839.                 if(times!=null) {
  840.                     long timeEnd =  DateManager.getTimeMillis();
  841.                     long timeProcess = timeEnd-timeStart;
  842.                     times.update = timeProcess;
  843.                 }
  844.             }
  845.             
  846.         }catch(Exception e){
  847.             throw new ProtocolException(e);
  848.         }
  849.         finally{
  850.             try{
  851.                 if(pstmt!=null)
  852.                     pstmt.close();
  853.             }catch(Exception eClose){
  854.                 // close
  855.             }
  856.         }
  857.         
  858.     }
  859. }

  861. class TransazioniFiltroDuplicatiProcessTimes{

  863.     long getConnection = -1;
  864.     long read = -1;
  865.     long update = -1;
  866.     long checkExistsRequest = -1;
  867.     long checkExistsResponse = -1;
  868.     long checkSleep = -1;
  869.     
  870.     @Override
  871.     public String toString() {
  872.         StringBuilder sb = new StringBuilder();
  873.         if(this.getConnection>=0) {
  874.             if(sb.length()>0) {
  875.                 sb.append(" ");
  876.             }
  877.             sb.append("getConnection:").append(this.getConnection);
  878.         }
  879.         if(this.read>=0) {
  880.             if(sb.length()>0) {
  881.                 sb.append(" ");
  882.             }
  883.             sb.append("read:").append(this.read);
  884.         }
  885.         if(this.update>=0) {
  886.             if(sb.length()>0) {
  887.                 sb.append(" ");
  888.             }
  889.             sb.append("update:").append(this.update);
  890.         }
  891.         if(this.checkExistsRequest>=0) {
  892.             if(sb.length()>0) {
  893.                 sb.append(" ");
  894.             }
  895.             sb.append("checkExistsRequest:").append(this.checkExistsRequest);
  896.         }
  897.         if(this.checkExistsResponse>=0) {
  898.             if(sb.length()>0) {
  899.                 sb.append(" ");
  900.             }
  901.             sb.append("checkExistsResponse:").append(this.checkExistsResponse);
  902.         }
  903.         if(this.checkSleep>=0) {
  904.             if(sb.length()>0) {
  905.                 sb.append(" ");
  906.             }
  907.             sb.append("checkSleep:").append(this.checkSleep);
  908.         }
  909.         return sb.toString();
  910.     }
  911. }
Created with JaCoCo 0.8.8.202204050719