TimerGestoreMessaggiLib.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.pdd.timers;

  25. import java.sql.Connection;
  26. import java.util.Date;
  27. import java.util.List;

  29. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  30. import org.openspcoop2.core.id.IDPortaApplicativa;
  31. import org.openspcoop2.core.transazioni.TransazioneApplicativoServer;
  32. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  33. import org.openspcoop2.pdd.core.CostantiPdD;
  34. import org.openspcoop2.pdd.core.GestoreCorrelazioneApplicativa;
  35. import org.openspcoop2.pdd.core.GestoreCorrelazioneApplicativaConfig;
  36. import org.openspcoop2.pdd.core.GestoreMessaggi;
  37. import org.openspcoop2.pdd.core.JMSReceiver;
  38. import org.openspcoop2.pdd.core.MessaggioServizioApplicativo;
  39. import org.openspcoop2.pdd.core.connettori.IConnettore;
  40. import org.openspcoop2.pdd.core.connettori.RepositoryConnettori;
  41. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  42. import org.openspcoop2.pdd.core.transazioni.GestoreConsegnaMultipla;
  43. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  44. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  45. import org.openspcoop2.pdd.services.core.RicezioneBuste;
  46. import org.openspcoop2.pdd.services.core.RicezioneContenutiApplicativi;
  47. import org.openspcoop2.protocol.engine.constants.Costanti;
  48. import org.openspcoop2.protocol.engine.driver.RollbackRepositoryBuste;
  49. import org.openspcoop2.protocol.sdk.state.StateMessage;
  50. import org.openspcoop2.utils.TipiDatabase;
  51. import org.openspcoop2.utils.Utilities;
  52. import org.openspcoop2.utils.date.DateManager;
  53. import org.openspcoop2.utils.id.serial.InfoStatistics;
  54. import org.openspcoop2.utils.semaphore.Semaphore;
  55. import org.openspcoop2.utils.semaphore.SemaphoreConfiguration;
  56. import org.openspcoop2.utils.semaphore.SemaphoreMapping;
  57. import org.slf4j.Logger;


  60. /**
  61.  * Implementazione dell'interfaccia {@link TimerGestoreMessaggi} del Gestore
  62.  * dei threads di servizio di OpenSPCoop.
  63.  * 
  64.  *  
  65.  * @author Poli Andrea (apoli@link.it)
  66.  * @author $Author$
  67.  * @version $Rev$, $Date$
  68.  */

  70. public class TimerGestoreMessaggiLib  {

  72.     private static TimerState STATE_MESSAGGI_ELIMINATI = TimerState.OFF; // abilitato in OpenSPCoop2Startup al momento dell'avvio
  73.     public static TimerState getSTATE_MESSAGGI_ELIMINATI() {
  74.         return STATE_MESSAGGI_ELIMINATI;
  75.     }
  76.     public static void setSTATE_MESSAGGI_ELIMINATI(TimerState sTATE_MESSAGGI_ELIMINATI) {
  77.         STATE_MESSAGGI_ELIMINATI = sTATE_MESSAGGI_ELIMINATI;
  78.     }

  80.     private static TimerState STATE_MESSAGGI_SCADUTI = TimerState.OFF; // abilitato in OpenSPCoop2Startup al momento dell'avvio
  81.     public static TimerState getSTATE_MESSAGGI_SCADUTI() {
  82.         return STATE_MESSAGGI_SCADUTI;
  83.     }
  84.     public static void setSTATE_MESSAGGI_SCADUTI(TimerState sTATE_MESSAGGI_SCADUTI) {
  85.         STATE_MESSAGGI_SCADUTI = sTATE_MESSAGGI_SCADUTI;
  86.     }

  88.     private static TimerState STATE_MESSAGGI_NON_GESTITI = TimerState.OFF; // abilitato in OpenSPCoop2Startup al momento dell'avvio
  89.     public static TimerState getSTATE_MESSAGGI_NON_GESTITI() {
  90.         return STATE_MESSAGGI_NON_GESTITI;
  91.     }
  92.     public static void setSTATE_MESSAGGI_NON_GESTITI(TimerState sTATE_MESSAGGI_NON_GESTITI) {
  93.         STATE_MESSAGGI_NON_GESTITI = sTATE_MESSAGGI_NON_GESTITI;
  94.     }

  96.     private static TimerState STATE_CORRELAZIONE_APPLICATIVA = TimerState.OFF; // abilitato in OpenSPCoop2Startup al momento dell'avvio
  97.     public static TimerState getSTATE_CORRELAZIONE_APPLICATIVA() {
  98.         return STATE_CORRELAZIONE_APPLICATIVA;
  99.     }
  100.     public static void setSTATE_CORRELAZIONE_APPLICATIVA(TimerState sTATE_CORRELAZIONE_APPLICATIVA) {
  101.         STATE_CORRELAZIONE_APPLICATIVA = sTATE_CORRELAZIONE_APPLICATIVA;
  102.     }

  104.     private static TimerState STATE_VERIFICA_CONNESSIONI_ATTIVE = TimerState.OFF; // abilitato in OpenSPCoop2Startup al momento dell'avvio
  105.     public static TimerState getSTATE_VERIFICA_CONNESSIONI_ATTIVE() {
  106.         return STATE_VERIFICA_CONNESSIONI_ATTIVE;
  107.     }
  108.     public static void setSTATE_VERIFICA_CONNESSIONI_ATTIVE(TimerState sTATE_VERIFICA_CONNESSIONI_ATTIVE) {
  109.         STATE_VERIFICA_CONNESSIONI_ATTIVE = sTATE_VERIFICA_CONNESSIONI_ATTIVE;
  110.     }

  112.     private MsgDiagnostico msgDiag = null;
  113.     private Logger logTimer = null;
  114.     private OpenSPCoop2Properties propertiesReader = null;
  115.     private long scadenzaMessaggio = -1;
  116.     private boolean logQuery = false;
  117.     private int limit = CostantiPdD.LIMIT_MESSAGGI_GESTORI;
  118.     private boolean orderByQuery;
  119.     private long scadenzaCorrelazioneApplicativa;
  120.     private boolean filtraCorrelazioniApplicativeScaduteRispettoOraRegistrazione;
  121.     private boolean filtraCorrelazioniApplicativeScaduteRispettoOraRegistrazione_escludiCorrelazioniConScadenzaImpostata;

  123.     private TimerLock timerLock = null;
  124.     private TimerLock timerLockCorrelazioneApplicativa = null;

  126.     /** Semaforo */
  127.     private Semaphore semaphore = null;
  128.     private InfoStatistics semaphore_statistics;

  130.     public TimerGestoreMessaggiLib(MsgDiagnostico msgDiag,Logger log,OpenSPCoop2Properties p,
  131.             long scadenzaMessaggio,boolean logQuery,
  132.             int limit,boolean orderByQuery, 
  133.             long scadenzaCorrelazioneApplicativa,
  134.             boolean filtraCorrelazioniApplicativeScaduteRispettoOraRegistrazione,
  135.             boolean filtraCorrelazioniApplicativeScaduteRispettoOraRegistrazione_escludiCorrelazioniConScadenzaImpostata) throws TimerException{
  136.         this.msgDiag = msgDiag;
  137.         this.logTimer = log;
  138.         this.propertiesReader = p;
  139.         this.scadenzaMessaggio = scadenzaMessaggio;
  140.         this.logQuery = logQuery;
  141.         this.limit = limit;
  142.         this.orderByQuery = orderByQuery;
  143.         this.scadenzaCorrelazioneApplicativa = scadenzaCorrelazioneApplicativa;
  144.         this.filtraCorrelazioniApplicativeScaduteRispettoOraRegistrazione = filtraCorrelazioniApplicativeScaduteRispettoOraRegistrazione;
  145.         this.filtraCorrelazioniApplicativeScaduteRispettoOraRegistrazione_escludiCorrelazioniConScadenzaImpostata =
  146.                 filtraCorrelazioniApplicativeScaduteRispettoOraRegistrazione_escludiCorrelazioniConScadenzaImpostata;

  148.         // deve essere utilizzato lo stesso lock per GestoreMessaggi, ConsegnaContenuti, GestoreBuste per risolvere problema di eliminazione descritto in GestoreMessaggi metodo deleteMessageWithLock
  149.         if(this.propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  150.             this.timerLock = new TimerLock(TipoLock._getLockGestioneRepositoryMessaggi());
  151.         }
  152.         else {
  153.             this.timerLock = new TimerLock(TipoLock.GESTIONE_PULIZIA_REPOSITORY_MESSAGGI);
  154.         }

  156.         this.timerLockCorrelazioneApplicativa = new TimerLock(TipoLock.GESTIONE_CORRELAZIONE_APPLICATIVA); 

  158.         if(this.propertiesReader.isTimerLockByDatabase()) {
  159.             this.semaphore_statistics = new InfoStatistics();

  161.             SemaphoreConfiguration config = GestoreMessaggi.newSemaphoreConfiguration(this.propertiesReader.getTimerGestoreMessaggiLockMaxLife(), 
  162.                     this.propertiesReader.getTimerGestoreMessaggiLockIdleTime());

  164.             TipiDatabase databaseType = TipiDatabase.toEnumConstant(this.propertiesReader.getDatabaseType());
  165.             try {
  166.                 this.semaphore = new Semaphore(this.semaphore_statistics, SemaphoreMapping.newInstance(this.timerLock.getIdLock()), 
  167.                         config, databaseType, this.logTimer);
  168.             }catch(Exception e) {
  169.                 throw new TimerException(e.getMessage(),e);
  170.             }
  171.         }
  172.     }


  175.     public void check() throws TimerException {

  177.         // Controllo che il sistema non sia andando in shutdown
  178.         if(OpenSPCoop2Startup.contextDestroyed){
  179.             this.logTimer.error("["+TimerGestoreMessaggi.ID_MODULO+"] Rilevato sistema in shutdown");
  180.             return;
  181.         }

  183.         // Controllo che l'inizializzazione corretta delle risorse sia effettuata
  184.         if(!OpenSPCoop2Startup.initialize){
  185.             this.msgDiag.logFatalError("inizializzazione di OpenSPCoop non effettuata", "Check Inizializzazione");
  186.             String msgErrore = "Riscontrato errore: inizializzazione del Timer o di OpenSPCoop non effettuata";
  187.             this.logTimer.error(msgErrore);
  188.             throw new TimerException(msgErrore);
  189.         }

  191.         // Controllo risorse di sistema disponibili
  192.         if( !TimerMonitoraggioRisorseThread.isRisorseDisponibili()){
  193.             this.logTimer.error("["+TimerGestoreMessaggi.ID_MODULO+"] Risorse di sistema non disponibili: "+TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile().getMessage(),TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile());
  194.             return;
  195.         }
  196.         if( !MsgDiagnostico.gestoreDiagnosticaDisponibile){
  197.             this.logTimer.error("["+TimerGestoreMessaggi.ID_MODULO+"] Sistema di diagnostica non disponibile: "+MsgDiagnostico.motivoMalfunzionamentoDiagnostici.getMessage(),MsgDiagnostico.motivoMalfunzionamentoDiagnostici);
  198.             return;
  199.         }
  200.         
  201.         // Controllo che il timer non sia stato momentaneamente disabilitato
  202.         if(!TimerState.ENABLED.equals(STATE_MESSAGGI_ELIMINATI) && 
  203.                 !TimerState.ENABLED.equals(STATE_MESSAGGI_SCADUTI) && 
  204.                 !TimerState.ENABLED.equals(STATE_MESSAGGI_NON_GESTITI) &&
  205.                 !TimerState.ENABLED.equals(STATE_CORRELAZIONE_APPLICATIVA) && 
  206.                 !TimerState.ENABLED.equals(STATE_VERIFICA_CONNESSIONI_ATTIVE)) {
  207.             this.msgDiag.logPersonalizzato("disabilitato");
  208.             this.logTimer.info(this.msgDiag.getMessaggio_replaceKeywords("disabilitato"));
  209.             return;
  210.         }

  212.         // Prendo la gestione
  213.         this.msgDiag.logPersonalizzato("controlloInCorso");
  214.         this.logTimer.info(this.msgDiag.getMessaggio_replaceKeywords("controlloInCorso"));
  215.         long startControlloRepositoryMessaggi = DateManager.getTimeMillis();

  217.         GestoreMessaggi gestoreMsg= null;
  218.         RollbackRepositoryBuste rollbackMessaggio = null;
  219.         RollbackRepositoryBuste rollbackRepository = null;


  222.         OpenSPCoopStateful openspcoopstate = new OpenSPCoopStateful();
  223.         try {
  224.             openspcoopstate.initResource(this.propertiesReader.getIdentitaPortaDefaultWithoutProtocol(),TimerGestoreMessaggi.ID_MODULO, null);
  225.             Connection connectionDB = ((StateMessage)openspcoopstate.getStatoRichiesta()).getConnectionDB();

  227.             // filtroJMS
  228.             JMSReceiver receiverJMS = null;
  229.             if(CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(this.propertiesReader.getNodeReceiver()))
  230.                 receiverJMS = new JMSReceiver(this.propertiesReader.getIdentitaPortaDefaultWithoutProtocol(),"ForcedDeleteMessage",this.propertiesReader.singleConnectionNodeReceiver(),this.logTimer, null);

  232.             // Messaggi da eliminare 
  233.             GestoreMessaggi gestoreMsgSearch = new GestoreMessaggi(openspcoopstate, true,this.logTimer,this.msgDiag, null);
  234.             long timeoutRicezioneContenutiApplicativiNonGestiti = this.propertiesReader.getNodeReceiverTimeoutRicezioneContenutiApplicativi() * 3;
  235.             long timeoutRicezioneBusteNonGestiti = this.propertiesReader.getNodeReceiverTimeoutRicezioneBuste() * 3;
  236.             boolean trovatiMessaggi = true;

  238.             while(trovatiMessaggi){

  240.                 trovatiMessaggi = false;


  243.                 Date now = null;
  244.                 if(!this.propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  245.                     now = DateManager.getDate(); // vedi spiegazione nel metodo deleteMessageByOraRegistrazione di GestoreMessaggi
  246.                 }


  249.                 /* --- Messaggi da eliminare (non scaduti) --- */ 
  250.                 
  251.                 List<String> idMsgInutiliINBOX = null;
  252.                 List<String> idMsgInutiliOUTBOX = null;
  253.                 
  254.                 if(TimerState.ENABLED.equals(STATE_MESSAGGI_ELIMINATI)) {
  255.                 
  256.                     // Eliminazione Messaggi from INBOX
  257.                     String causaMessaggiINBOXDaEliminareNonScaduti = "Eliminazione messaggi INBOX marcati logicamente da eliminare";
  258.                     try{
  259.                         GestoreMessaggi.acquireLock(
  260.                                 this.semaphore, connectionDB, this.timerLock,
  261.                                 this.msgDiag, causaMessaggiINBOXDaEliminareNonScaduti, 
  262.                                 this.propertiesReader.getTimerGestoreMessaggi_getLockAttesaAttiva(), 
  263.                                 this.propertiesReader.getTimerGestoreMessaggi_getLockCheckInterval());
  264.     
  265.                         idMsgInutiliINBOX = gestoreMsgSearch.readMessaggiInutiliIntoInbox(TimerGestoreMessaggi.ID_MODULO,this.limit,this.logQuery,this.orderByQuery,now);
  266.                         int gestiti = 0;
  267.                         if(idMsgInutiliINBOX.size()>0){
  268.                             if(this.logQuery)
  269.                                 this.logTimer.info("Trovati "+idMsgInutiliINBOX.size()+" messaggi (cancellazione logica) da eliminare nel repository (INBOX) ...");
  270.                             trovatiMessaggi = true;
  271.     
  272.                             this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_TIPO_RICERCA_MSG_DA_ELIMINARE,"MessaggiCompletati");
  273.                             this.msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO,Costanti.INBOX);
  274.                             for(int i=0; i<idMsgInutiliINBOX.size(); i++){
  275.     
  276.                                 String idMsgDaEliminare = idMsgInutiliINBOX.get(i);
  277.                                 this.msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_DA_ELIMINARE,idMsgDaEliminare);
  278.     
  279.                                 try{
  280.                                     try{
  281.                                         GestoreMessaggi.updateLock(
  282.                                                 this.semaphore, connectionDB, this.timerLock,
  283.                                                 this.msgDiag, "Eliminazione messaggio INBOX con id ["+idMsgDaEliminare+"] ...");
  284.                                     }catch(Throwable e){
  285.                                         this.msgDiag.logErroreGenerico(e,"EliminazioneMessaggioInbox("+idMsgDaEliminare+")-UpdateLock");
  286.                                         this.logTimer.error("ErroreEliminazioneMessaggioInbox("+idMsgDaEliminare+")-UpdateLock: "+e.getMessage(),e);
  287.                                         break;
  288.                                     }
  289.     
  290.                                     // eliminazione messaggio
  291.                                     gestoreMsg = new GestoreMessaggi(openspcoopstate, true
  292.                                             ,idMsgDaEliminare,Costanti.INBOX,this.msgDiag,null);
  293.                                     if(this.propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  294.                                         gestoreMsg._deleteMessageWithoutLock();
  295.                                     }
  296.                                     else {
  297.                                         gestoreMsg.deleteMessageByOraRegistrazione(now);
  298.                                     }
  299.     
  300.                                     this.msgDiag.logPersonalizzato("eliminazioneMessaggio");
  301.                                     if(this.logQuery)
  302.                                         this.logTimer.debug(this.msgDiag.getMessaggio_replaceKeywords("eliminazioneMessaggio"));
  303.     
  304.                                     gestiti++;
  305.     
  306.                                 }catch(Exception e){
  307.                                     this.msgDiag.logErroreGenerico(e,"EliminazioneMessaggioInbox("+idMsgDaEliminare+")");
  308.                                     this.logTimer.error("ErroreEliminazioneMessaggioInbox("+idMsgDaEliminare+"): "+e.getMessage(),e);
  309.                                 }
  310.                             }
  311.     
  312.                             if(this.logQuery)
  313.                                 this.logTimer.info("Eliminati "+gestiti+" messaggi (cancellazione logica) nel repository (INBOX)");
  314.                         }
  315.                         else{
  316.                             if(this.logQuery)
  317.                                 this.logTimer.info("Non sono stati trovati messaggi (cancellazione logica) da eliminare nel repository (INBOX)");
  318.                         }
  319.                     }finally{
  320.                         try{
  321.                             GestoreMessaggi.releaseLock(
  322.                                     this.semaphore, connectionDB, this.timerLock,
  323.                                     this.msgDiag, causaMessaggiINBOXDaEliminareNonScaduti);
  324.                         }catch(Exception e){
  325.                             // ignore
  326.                         }
  327.                     }
  328.     
  329.                     //  Eliminazione Messaggi from OUTBOX
  330.                     String causaMessaggiOUTBOXDaEliminareNonScaduti = "Eliminazione messaggi OUTBOX marcati logicamente da eliminare";
  331.                     try{
  332.                         GestoreMessaggi.acquireLock(
  333.                                 this.semaphore, connectionDB, this.timerLock,
  334.                                 this.msgDiag, causaMessaggiOUTBOXDaEliminareNonScaduti, 
  335.                                 this.propertiesReader.getTimerGestoreMessaggi_getLockAttesaAttiva(), 
  336.                                 this.propertiesReader.getTimerGestoreMessaggi_getLockCheckInterval());
  337.     
  338.                         idMsgInutiliOUTBOX = gestoreMsgSearch.readMessaggiInutiliIntoOutbox(TimerGestoreMessaggi.ID_MODULO,this.limit,this.logQuery,this.orderByQuery,now);
  339.                         int gestiti = 0;
  340.                         if(idMsgInutiliOUTBOX.size()>0){
  341.                             if(this.logQuery)
  342.                                 this.logTimer.info("Trovati "+idMsgInutiliOUTBOX.size()+" messaggi (cancellazione logica) da eliminare nel repository (OUTBOX) ...");
  343.                             trovatiMessaggi = true;
  344.     
  345.                             this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_TIPO_RICERCA_MSG_DA_ELIMINARE,"MessaggiCompletati");
  346.                             this.msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO,Costanti.OUTBOX);
  347.                             for(int i=0; i<idMsgInutiliOUTBOX.size(); i++){
  348.     
  349.                                 String idMsgDaEliminare = idMsgInutiliOUTBOX.get(i);
  350.                                 this.msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_DA_ELIMINARE,idMsgDaEliminare);
  351.     
  352.                                 try{
  353.                                     try{
  354.                                         GestoreMessaggi.updateLock(
  355.                                                 this.semaphore, connectionDB, this.timerLock,
  356.                                                 this.msgDiag, "Eliminazione messaggio OUTBOX con id ["+idMsgDaEliminare+"] ...");
  357.                                     }catch(Throwable e){
  358.                                         this.msgDiag.logErroreGenerico(e,"EliminazioneMessaggioOutbox("+idMsgDaEliminare+")-UpdateLock");
  359.                                         this.logTimer.error("ErroreEliminazioneMessaggioOutbox("+idMsgDaEliminare+")-UpdateLock: "+e.getMessage(),e);
  360.                                         break;
  361.                                     }
  362.     
  363.                                     // eliminazione messaggio
  364.                                     gestoreMsg = new GestoreMessaggi(openspcoopstate, true,idMsgDaEliminare,Costanti.OUTBOX,this.msgDiag,null);
  365.                                     if(this.propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  366.                                         gestoreMsg._deleteMessageWithoutLock();
  367.                                     }
  368.                                     else {
  369.                                         gestoreMsg.deleteMessageByOraRegistrazione(now);
  370.                                     }
  371.     
  372.                                     this.msgDiag.logPersonalizzato("eliminazioneMessaggio");
  373.                                     if(this.logQuery)
  374.                                         this.logTimer.debug(this.msgDiag.getMessaggio_replaceKeywords("eliminazioneMessaggio"));
  375.     
  376.                                     gestiti++;
  377.     
  378.                                 }catch(Exception e){
  379.                                     this.msgDiag.logErroreGenerico(e,"EliminazioneMessaggioOutbox("+idMsgDaEliminare+")");
  380.                                     this.logTimer.error("ErroreEliminazioneMessaggioOutbox("+idMsgDaEliminare+"): "+e.getMessage(),e);
  381.                                 }       
  382.                             }
  383.     
  384.                             if(this.logQuery)
  385.                                 this.logTimer.info("Eliminati "+gestiti+" messaggi (cancellazione logica) nel repository (OUTBOX)");
  386.                         }
  387.                         else{
  388.                             if(this.logQuery)
  389.                                 this.logTimer.info("Non sono stati trovati messaggi (cancellazione logica) da eliminare nel repository (OUTBOX)");
  390.                         }
  391.                     }finally{
  392.                         try{
  393.                             GestoreMessaggi.releaseLock(
  394.                                     this.semaphore, connectionDB, this.timerLock,
  395.                                     this.msgDiag, causaMessaggiOUTBOXDaEliminareNonScaduti);
  396.                         }catch(Exception e){
  397.                             // ignore
  398.                         }
  399.                     }
  400.                     
  401.                 }
  402.                 else {
  403.                     if(this.logQuery) {
  404.                         this.logTimer.info("Gestione messaggi (cancellazione logica) disabilitata");
  405.                     }   
  406.                 }






  413.                 /* --- Messaggi scaduti, verra' effettuato anche un rollback delle Buste. --- */

  415.                 List<String> idMsgScadutiINBOX = null;
  416.                 List<String> idMsgScadutiOUTBOX = null;
  417.                 
  418.                 if(TimerState.ENABLED.equals(STATE_MESSAGGI_SCADUTI)) {
  419.                 
  420.                     //  Eliminazione Messaggi from INBOX
  421.                     String causaMessaggiINBOXScaduti = "Eliminazione messaggi INBOX scaduti";
  422.                     try{
  423.                         GestoreMessaggi.acquireLock(
  424.                                 this.semaphore, connectionDB, this.timerLock,
  425.                                 this.msgDiag, causaMessaggiINBOXScaduti, 
  426.                                 this.propertiesReader.getTimerGestoreMessaggi_getLockAttesaAttiva(), 
  427.                                 this.propertiesReader.getTimerGestoreMessaggi_getLockCheckInterval());
  428.     
  429.                         idMsgScadutiINBOX = gestoreMsgSearch.readMessaggiScadutiIntoInbox(this.scadenzaMessaggio,this.limit,this.logQuery,this.orderByQuery,now);
  430.                         int gestiti = 0;
  431.                         if(idMsgScadutiINBOX.size()>0){
  432.                             if(this.logQuery)
  433.                                 this.logTimer.info("Trovati "+idMsgScadutiINBOX.size()+" messaggi (scaduti) da eliminare nel repository (INBOX) ...");
  434.                             trovatiMessaggi = true;
  435.     
  436.                             this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_TIPO_RICERCA_MSG_DA_ELIMINARE,"MessaggiScaduti");
  437.                             this.msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO,Costanti.INBOX);
  438.                             for(int i=0; i<idMsgScadutiINBOX.size(); i++){
  439.     
  440.                                 String idMsgDaEliminare = idMsgScadutiINBOX.get(i);
  441.                                 this.msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_DA_ELIMINARE,idMsgDaEliminare);
  442.     
  443.                                 try{
  444.                                     try{
  445.                                         GestoreMessaggi.updateLock(
  446.                                                 this.semaphore, connectionDB, this.timerLock,
  447.                                                 this.msgDiag, "Eliminazione messaggio scaduto INBOX con id ["+idMsgDaEliminare+"] ...");
  448.                                     }catch(Throwable e){
  449.                                         this.msgDiag.logErroreGenerico(e,"EliminazioneMessaggioScadutoInbox("+idMsgDaEliminare+")-UpdateLock");
  450.                                         this.logTimer.error("ErroreEliminazioneMessaggioScadutoInbox("+idMsgDaEliminare+")-UpdateLock: "+e.getMessage(),e);
  451.                                         break;
  452.                                     }
  453.     
  454.                                     gestoreMsg = new GestoreMessaggi(openspcoopstate, true,idMsgDaEliminare,Costanti.INBOX,this.msgDiag,null);
  455.     
  456.                                     //  rollback messaggio scaduto (eventuale profilo + accesso_pdd)
  457.                                     rollbackMessaggio = new RollbackRepositoryBuste(idMsgDaEliminare,openspcoopstate.getStatoRichiesta(),true);
  458.                                     rollbackMessaggio.rollbackBustaIntoInBox();
  459.     
  460.                                     // rollback repository + // rollback jms receiver
  461.                                     String rifMsg = gestoreMsg.getRiferimentoMessaggio();
  462.                                     if(rifMsg==null){
  463.                                         if(receiverJMS!=null){
  464.                                             // rollback jms receiver
  465.                                             String strMessageSelector = "ID = '"+idMsgDaEliminare+"'";
  466.                                             if (receiverJMS.clean(RicezioneBuste.ID_MODULO,strMessageSelector)){
  467.                                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_CODA_JMS_FILTRO_MSG_DA_ELIMINARE,
  468.                                                         RicezioneBuste.ID_MODULO);
  469.                                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_RICERCA_MSG_DA_ELIMINARE_PER_RIFERIMENTO,"false");
  470.                                                 this.msgDiag.logPersonalizzato("messaggioNonConsumato.codaJMS");
  471.                                             }
  472.                                         }
  473.                                     }else{
  474.                                         // rollback repository
  475.                                         rollbackRepository = new RollbackRepositoryBuste(rifMsg,openspcoopstate.getStatoRichiesta(),true);
  476.                                         rollbackRepository.rollbackBustaIntoOutBox(false); // non effettuo il rollback dell'history (riscontro/ricevuta arrivera...)
  477.     
  478.                                         if(receiverJMS!=null){
  479.                                             // rollback jms receiver
  480.                                             String strMessageSelector = "ID = '"+rifMsg+"'";
  481.                                             if (receiverJMS.clean(RicezioneContenutiApplicativi.ID_MODULO,strMessageSelector)){
  482.                                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_CODA_JMS_FILTRO_MSG_DA_ELIMINARE,
  483.                                                         RicezioneContenutiApplicativi.ID_MODULO);
  484.                                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_RICERCA_MSG_DA_ELIMINARE_PER_RIFERIMENTO,"true");
  485.                                                 this.msgDiag.logPersonalizzato("messaggioNonConsumato.codaJMS");
  486.                                             }
  487.                                         }
  488.                                     }
  489.     
  490.                                     // aggiorno eventuali destinatari nella transazione prima di eliminare il messaggio
  491.                                     try {
  492.                                         List<MessaggioServizioApplicativo> listMsgServiziApplicativi = gestoreMsg.readInfoDestinatari(this.logQuery, this.logTimer);
  493.                                         if(listMsgServiziApplicativi!=null && !listMsgServiziApplicativi.isEmpty()) {
  494.                                             
  495.                                             for (MessaggioServizioApplicativo messaggioServizioApplicativo : listMsgServiziApplicativi) {
  496.                                                 TransazioneApplicativoServer transazioneApplicativoServer = new TransazioneApplicativoServer();
  497.                                                 transazioneApplicativoServer.setIdTransazione(messaggioServizioApplicativo.getIdTransazione());
  498.                                                 transazioneApplicativoServer.setServizioApplicativoErogatore(messaggioServizioApplicativo.getServizioApplicativo());
  499.                                                 transazioneApplicativoServer.setDataRegistrazione(messaggioServizioApplicativo.getOraRegistrazione());
  500.                                                 transazioneApplicativoServer.setDataMessaggioScaduto(DateManager.getDate());
  501.                                                 transazioneApplicativoServer.setProtocollo(this.propertiesReader.getDefaultProtocolName()); // non è importante per impostare la scadenza
  502.                                                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  503.                                                 idPA.setNome(messaggioServizioApplicativo.getNomePorta());
  504.                                                 try {
  505.                                                     GestoreConsegnaMultipla.getInstance().safeUpdateMessaggioScaduto(transazioneApplicativoServer, idPA, openspcoopstate);
  506.                                                 }catch(Throwable t) {
  507.                                                     this.logTimer.error("["+transazioneApplicativoServer.getIdTransazione()+"]["+transazioneApplicativoServer.getServizioApplicativoErogatore()+"] Errore durante il salvataggio delle informazioni relative al servizio applicativo: "+t.getMessage(),t);
  508.                                                 }
  509.                                             }
  510.                                         }
  511.                                     }catch(Throwable t) {
  512.                                         this.logTimer.error("Errore durante l'aggiornamento dello stato degli applicativi nelle transazioni: "+t.getMessage(),t);
  513.                                     }
  514.                                     
  515.                                     // Eliminazione effettiva
  516.                                     ((StateMessage)openspcoopstate.getStatoRichiesta()).executePreparedStatement();
  517.                                     //  eliminazione messaggio
  518.                                     if(this.propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  519.                                         gestoreMsg._deleteMessageWithoutLock();
  520.                                     }
  521.                                     else {
  522.                                         gestoreMsg.deleteMessageByOraRegistrazione(now);
  523.                                     }
  524.     
  525.                                     this.msgDiag.logPersonalizzato("eliminazioneMessaggio");
  526.                                     if(this.logQuery)
  527.                                         this.logTimer.debug(this.msgDiag.getMessaggio_replaceKeywords("eliminazioneMessaggio"));
  528.     
  529.                                     gestiti++;
  530.     
  531.                                 }catch(Exception e){
  532.     
  533.                                     ((StateMessage)openspcoopstate.getStatoRichiesta()).closePreparedStatement();
  534.                                     this.msgDiag.logErroreGenerico(e,"EliminazioneMessaggioScadutoInbox("+idMsgDaEliminare+")");
  535.                                     this.logTimer.error("ErroreEliminazioneMessaggioScadutoInbox("+idMsgDaEliminare+"): "+e.getMessage(),e);
  536.                                 }
  537.                             }
  538.     
  539.                             if(this.logQuery)
  540.                                 this.logTimer.info("Eliminati "+gestiti+" messaggi (scaduti) nel repository (INBOX)");
  541.                         }
  542.                         else{
  543.                             if(this.logQuery)
  544.                                 this.logTimer.info("Non sono stati trovati messaggi (scaduti) da eliminare nel repository (INBOX)");
  545.                         }
  546.                     }finally{
  547.                         try{
  548.                             GestoreMessaggi.releaseLock(
  549.                                     this.semaphore, connectionDB, this.timerLock,
  550.                                     this.msgDiag, causaMessaggiINBOXScaduti);
  551.                         }catch(Exception e){
  552.                             // ignore
  553.                         }
  554.                     }
  555.     
  556.                     // Eliminazione Messaggi from OUTBOX
  557.                     String causaMessaggiOUTBOXScaduti = "Eliminazione messaggi OUTBOX scaduti";
  558.                     try{
  559.                         GestoreMessaggi.acquireLock(
  560.                                 this.semaphore, connectionDB, this.timerLock,
  561.                                 this.msgDiag, causaMessaggiOUTBOXScaduti, 
  562.                                 this.propertiesReader.getTimerGestoreMessaggi_getLockAttesaAttiva(), 
  563.                                 this.propertiesReader.getTimerGestoreMessaggi_getLockCheckInterval());
  564.     
  565.                         idMsgScadutiOUTBOX = gestoreMsgSearch.readMessaggiScadutiIntoOutbox(this.scadenzaMessaggio,this.limit,this.logQuery,this.orderByQuery, now);
  566.                         int gestiti = 0;
  567.                         if(idMsgScadutiOUTBOX.size()>0){
  568.                             if(this.logQuery)
  569.                                 this.logTimer.info("Trovati "+idMsgScadutiOUTBOX.size()+" messaggi (scaduti) da eliminare nel repository (OUTBOX) ...");
  570.                             trovatiMessaggi = true;
  571.     
  572.                             this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_TIPO_RICERCA_MSG_DA_ELIMINARE,"MessaggiScaduti");
  573.                             this.msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO,Costanti.OUTBOX);
  574.                             for(int i=0; i<idMsgScadutiOUTBOX.size(); i++){
  575.     
  576.                                 String idMsgDaEliminare = idMsgScadutiOUTBOX.get(i);
  577.                                 this.msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_DA_ELIMINARE,idMsgDaEliminare);
  578.     
  579.                                 try{
  580.                                     try{
  581.                                         GestoreMessaggi.updateLock(
  582.                                                 this.semaphore, connectionDB, this.timerLock,
  583.                                                 this.msgDiag, "Eliminazione messaggio scaduto OUTBOX con id ["+idMsgDaEliminare+"] ...");
  584.                                     }catch(Throwable e){
  585.                                         this.msgDiag.logErroreGenerico(e,"EliminazioneMessaggioScadutoOutbox("+idMsgDaEliminare+")-UpdateLock");
  586.                                         this.logTimer.error("ErroreEliminazioneMessaggioScadutoOutbox("+idMsgDaEliminare+")-UpdateLock: "+e.getMessage(),e);
  587.                                         break;
  588.                                     }
  589.     
  590.                                     gestoreMsg = new GestoreMessaggi(openspcoopstate, true,idMsgDaEliminare,Costanti.OUTBOX,this.msgDiag,null);
  591.     
  592.                                     //  rollback messaggio scaduto (eventuale profilo + accesso_pdd)
  593.                                     rollbackMessaggio = new RollbackRepositoryBuste(idMsgDaEliminare,openspcoopstate.getStatoRichiesta(),true);
  594.                                     rollbackMessaggio.rollbackBustaIntoOutBox();
  595.     
  596.                                     //  rollback repository + // rollback jms receiver
  597.                                     String rifMsg = gestoreMsg.getRiferimentoMessaggio();
  598.                                     if(rifMsg==null){
  599.                                         if(receiverJMS!=null){
  600.                                             //  rollback jms receiver
  601.                                             String strMessageSelector = "ID = '"+idMsgDaEliminare+"'";
  602.                                             if (receiverJMS.clean(RicezioneContenutiApplicativi.ID_MODULO,strMessageSelector)){
  603.                                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_CODA_JMS_FILTRO_MSG_DA_ELIMINARE,
  604.                                                         RicezioneContenutiApplicativi.ID_MODULO);
  605.                                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_RICERCA_MSG_DA_ELIMINARE_PER_RIFERIMENTO,"false");
  606.                                                 this.msgDiag.logPersonalizzato("messaggioNonConsumato.codaJMS");
  607.                                             }
  608.                                         }
  609.                                     }else{
  610.                                         // rollback repository
  611.                                         rollbackRepository = new RollbackRepositoryBuste(rifMsg,openspcoopstate.getStatoRichiesta(),true);
  612.                                         rollbackRepository.rollbackBustaIntoInBox(false); // non effettuo il rollback dell'history (busta e' ricevuta)
  613.     
  614.                                         if(receiverJMS!=null){
  615.                                             //  rollback jms receiver
  616.                                             String strMessageSelector = "ID = '"+rifMsg+"'";
  617.                                             if (receiverJMS.clean(RicezioneBuste.ID_MODULO,strMessageSelector)){
  618.                                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_CODA_JMS_FILTRO_MSG_DA_ELIMINARE,
  619.                                                         RicezioneBuste.ID_MODULO);
  620.                                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_RICERCA_MSG_DA_ELIMINARE_PER_RIFERIMENTO,"true");
  621.                                                 this.msgDiag.logPersonalizzato("messaggioNonConsumato.codaJMS");
  622.                                             }
  623.                                         }
  624.                                     }
  625.                                     ((StateMessage)openspcoopstate.getStatoRichiesta()).executePreparedStatement();
  626.                                     //  eliminazione messaggio
  627.                                     if(this.propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  628.                                         gestoreMsg._deleteMessageWithoutLock();
  629.                                     }
  630.                                     else {
  631.                                         gestoreMsg.deleteMessageByOraRegistrazione(now);
  632.                                     }
  633.     
  634.                                     this.msgDiag.logPersonalizzato("eliminazioneMessaggio");
  635.                                     if(this.logQuery)
  636.                                         this.logTimer.debug(this.msgDiag.getMessaggio_replaceKeywords("eliminazioneMessaggio"));
  637.     
  638.                                     gestiti++;
  639.     
  640.                                 }catch(Exception e){
  641.                                     ((StateMessage)openspcoopstate.getStatoRichiesta()).closePreparedStatement();
  642.                                     this.msgDiag.logErroreGenerico(e,"EliminazioneMessaggioScadutoOutbox("+idMsgDaEliminare+")");
  643.                                     this.logTimer.error("ErroreEliminazioneMessaggioScadutoOutbox("+idMsgDaEliminare+"): "+e.getMessage(),e);
  644.                                 }       
  645.                             }
  646.     
  647.                             if(this.logQuery)
  648.                                 this.logTimer.info("Eliminati "+gestiti+" messaggi (scaduti) nel repository (OUTBOX)");
  649.     
  650.                         }
  651.                         else{
  652.                             if(this.logQuery)
  653.                                 this.logTimer.info("Non sono stati trovati messaggi (scaduti) da eliminare nel repository (OUTBOX)");
  654.                         }
  655.                     }finally{
  656.                         try{
  657.                             GestoreMessaggi.releaseLock(
  658.                                     this.semaphore, connectionDB, this.timerLock,
  659.                                     this.msgDiag, causaMessaggiOUTBOXScaduti);
  660.                         }catch(Exception e){
  661.                             // ignore
  662.                         }
  663.                     }

  665.                 }
  666.                 else {
  667.                     if(this.logQuery) {
  668.                         this.logTimer.info("Gestione messaggi (scaduti) disabilitata");
  669.                     }   
  670.                 }




  675.                 List<String> idMsgServizioRicezioneContenutiApplicativiNonGestiti = null;
  676.                 List<String> idMsgServizioRicezioneBusteNonGestiti = null;
  677.                 
  678.                 if(TimerState.ENABLED.equals(STATE_MESSAGGI_NON_GESTITI)) {

  680.                     /* --- Messaggi non gestiti dal servizio web RicezioneContenutiApplicativi, verra' effettuato anche un rollback delle Buste. ---*/
  681.     
  682.                     //  Eliminazione Messaggi from INBOX
  683.                     String causaMessaggiINBOXNonGestitiRicezioneContenutiApplicativi = "Eliminazione messaggi INBOX non gestiti dal servizio RicezioneContenutiApplicativi";
  684.                     try{
  685.                         GestoreMessaggi.acquireLock(
  686.                                 this.semaphore, connectionDB, this.timerLock,
  687.                                 this.msgDiag, causaMessaggiINBOXNonGestitiRicezioneContenutiApplicativi, 
  688.                                 this.propertiesReader.getTimerGestoreMessaggi_getLockAttesaAttiva(), 
  689.                                 this.propertiesReader.getTimerGestoreMessaggi_getLockCheckInterval());
  690.     
  691.                         idMsgServizioRicezioneContenutiApplicativiNonGestiti = 
  692.                                 gestoreMsgSearch.readMsgForRicezioneContenutiApplicativiNonGestiti(timeoutRicezioneContenutiApplicativiNonGestiti, this.limit,this.logQuery,this.orderByQuery);
  693.                         int gestiti = 0;
  694.                         if(idMsgServizioRicezioneContenutiApplicativiNonGestiti.size()>0){
  695.                             if(this.logQuery)
  696.                                 this.logTimer.info("Trovati "+idMsgServizioRicezioneContenutiApplicativiNonGestiti.size()+" messaggi (non gestiti da 'RicezioneContenutiApplicativi') da eliminare nel repository (INBOX) ...");
  697.                             trovatiMessaggi = true;
  698.     
  699.                             this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_TIPO_RICERCA_MSG_DA_ELIMINARE,"MessaggiNonGestitiRicezioneContenutiApplicativi");
  700.                             this.msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO,Costanti.INBOX);
  701.                             for(int i=0; i<idMsgServizioRicezioneContenutiApplicativiNonGestiti.size(); i++){
  702.                                 String idMsgDaEliminare = idMsgServizioRicezioneContenutiApplicativiNonGestiti.get(i);
  703.                                 String idBustaDaEliminare = idMsgDaEliminare.split("@")[0];
  704.                                 String servizioApplicativoDaEliminare = idMsgDaEliminare.split("@")[1];
  705.                                 this.msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_DA_ELIMINARE,idBustaDaEliminare);
  706.     
  707.                                 try{
  708.                                     try{
  709.                                         GestoreMessaggi.updateLock(
  710.                                                 this.semaphore, connectionDB, this.timerLock,
  711.                                                 this.msgDiag, "Eliminazione messaggio INBOX non gestiti dal servizio RicezioneContenutiApplicativi con id ["+idMsgDaEliminare+"] ...");
  712.                                     }catch(Throwable e){
  713.                                         this.msgDiag.logErroreGenerico(e,"EliminazioneMessaggioRicezioneContenutiApplicativiNonGestiti("+idMsgDaEliminare+")-UpdateLock");
  714.                                         this.logTimer.error("ErroreEliminazioneMessaggioRicezioneContenutiApplicativiNonGestiti("+idMsgDaEliminare+")-UpdateLock: "+e.getMessage(),e);
  715.                                         break;
  716.                                     }
  717.     
  718.                                     gestoreMsg = new GestoreMessaggi(openspcoopstate, true,idBustaDaEliminare,Costanti.INBOX,this.msgDiag,null);
  719.     
  720.                                     // pulizia jms receiver
  721.                                     if(receiverJMS!=null){
  722.                                         String rifMsg = gestoreMsg.getRiferimentoMessaggio();
  723.                                         if(rifMsg!=null){
  724.                                             // rollback jms receiver
  725.                                             String strMessageSelector = "ID = '"+rifMsg+"'";
  726.                                             if (receiverJMS.clean(RicezioneContenutiApplicativi.ID_MODULO,strMessageSelector)){
  727.                                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_CODA_JMS_FILTRO_MSG_DA_ELIMINARE,
  728.                                                         RicezioneContenutiApplicativi.ID_MODULO);
  729.                                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_RICERCA_MSG_DA_ELIMINARE_PER_RIFERIMENTO,"true");
  730.                                                 this.msgDiag.logPersonalizzato("messaggioNonConsumato.codaJMS");
  731.                                             }
  732.                                         }
  733.                                     }
  734.     
  735.                                     //  eliminazione servizioApplicativo
  736.                                     gestoreMsg.eliminaDestinatarioMessaggio(servizioApplicativoDaEliminare,gestoreMsg.getRiferimentoMessaggio());
  737.     
  738.                                     // Se non ci sono altri destinatari effettua rollback
  739.                                     if(gestoreMsg.existsServiziApplicativiDestinatariMessaggio()==false){
  740.                                         rollbackMessaggio = new RollbackRepositoryBuste(idBustaDaEliminare,openspcoopstate.getStatoRichiesta(),true);
  741.                                         rollbackMessaggio.rollbackBustaIntoInBox();
  742.                                         ((StateMessage)openspcoopstate.getStatoRichiesta()).executePreparedStatement();
  743.                                     }
  744.     
  745.                                     this.msgDiag.logPersonalizzato("eliminazioneDestinatarioMessaggio");
  746.                                     if(this.logQuery)
  747.                                         this.logTimer.debug(this.msgDiag.getMessaggio_replaceKeywords("eliminazioneDestinatarioMessaggio"));
  748.     
  749.                                     gestiti++;
  750.     
  751.                                 }catch(Exception e){
  752.                                     if(rollbackMessaggio!=null){
  753.                                         ((StateMessage)openspcoopstate.getStatoRichiesta()).closePreparedStatement();
  754.                                         rollbackMessaggio = null;
  755.                                     }
  756.                                     this.msgDiag.logErroreGenerico(e,"EliminazioneMessaggioRicezioneContenutiApplicativiNonGestiti("+idMsgDaEliminare+")");
  757.                                     this.logTimer.error("ErroreEliminazioneMessaggioRicezioneContenutiApplicativiNonGestiti("+idMsgDaEliminare+"): "+e.getMessage(),e);
  758.                                 }
  759.                             }
  760.     
  761.                             if(this.logQuery)
  762.                                 this.logTimer.info("Eliminati "+gestiti+" messaggi (non gestiti da 'RicezioneContenutiApplicativi') nel repository (INBOX)");
  763.     
  764.                         }
  765.                         else{
  766.                             if(this.logQuery)
  767.                                 this.logTimer.info("Non sono stati trovati messaggi (non gestiti da 'RicezioneContenutiApplicativi') da eliminare nel repository (INBOX)");
  768.                         }
  769.                     }finally{
  770.                         try{
  771.                             GestoreMessaggi.releaseLock(
  772.                                     this.semaphore, connectionDB, this.timerLock,
  773.                                     this.msgDiag, causaMessaggiINBOXNonGestitiRicezioneContenutiApplicativi);
  774.                         }catch(Exception e){
  775.                             // ignore
  776.                         }
  777.                     }
  778.     
  779.     
  780.     
  781.                     /* --- Messaggi non gestiti dal servizio web RicezioneBuste, verra' effettuato anche un rollback delle Buste. --- */
  782.     
  783.                     //  Eliminazione Messaggi from OUTBOX
  784.                     String causaMessaggiOUTBOXNonGestitiRicezioneBuste = "Eliminazione messaggi OUTBOX non gestiti dal servizio RicezioneBuste";
  785.                     try{
  786.                         GestoreMessaggi.acquireLock(
  787.                                 this.semaphore, connectionDB, this.timerLock,
  788.                                 this.msgDiag, causaMessaggiOUTBOXNonGestitiRicezioneBuste, 
  789.                                 this.propertiesReader.getTimerGestoreMessaggi_getLockAttesaAttiva(), 
  790.                                 this.propertiesReader.getTimerGestoreMessaggi_getLockCheckInterval());
  791.     
  792.                         idMsgServizioRicezioneBusteNonGestiti = 
  793.                                 gestoreMsgSearch.readMsgForRicezioneBusteNonGestiti(timeoutRicezioneBusteNonGestiti, this.limit,this.logQuery,this.orderByQuery);
  794.                         int gestiti = 0;
  795.                         if(idMsgServizioRicezioneBusteNonGestiti.size()>0){
  796.                             if(this.logQuery)
  797.                                 this.logTimer.info("Trovati "+idMsgServizioRicezioneBusteNonGestiti.size()+" messaggi (non gestiti da 'RicezioneBuste') da eliminare nel repository (OUTBOX) ...");
  798.                             trovatiMessaggi = true;
  799.     
  800.                             this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_TIPO_RICERCA_MSG_DA_ELIMINARE,"MessaggiNonGestitiRicezioneBuste");
  801.                             this.msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO,Costanti.OUTBOX);
  802.                             for(int i=0; i<idMsgServizioRicezioneBusteNonGestiti.size(); i++){
  803.                                 String idMsgDaEliminare = idMsgServizioRicezioneBusteNonGestiti.get(i);
  804.                                 this.msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_DA_ELIMINARE,idMsgDaEliminare);
  805.                                 try{
  806.                                     try{
  807.                                         GestoreMessaggi.updateLock(
  808.                                                 this.semaphore, connectionDB, this.timerLock,
  809.                                                 this.msgDiag, "Eliminazione messaggio OUTBOX non gestiti dal servizio RicezioneBuste con id ["+idMsgDaEliminare+"] ...");
  810.                                     }catch(Throwable e){
  811.                                         this.msgDiag.logErroreGenerico(e,"EliminazioneMessaggioRicezioneBusteNonGestiti("+idMsgDaEliminare+")-UpdateLock");
  812.                                         this.logTimer.error("ErroreEliminazioneMessaggioRicezioneBusteNonGestiti("+idMsgDaEliminare+")-UpdateLock: "+e.getMessage(),e);
  813.                                         break;
  814.                                     }
  815.     
  816.                                     gestoreMsg = new GestoreMessaggi(openspcoopstate, true,idMsgDaEliminare,Costanti.OUTBOX,this.msgDiag,null);
  817.     
  818.                                     //  rollback messaggio scaduto (eventuale profilo + accesso_pdd)
  819.                                     rollbackMessaggio = new RollbackRepositoryBuste(idMsgDaEliminare,openspcoopstate.getStatoRichiesta(),true);
  820.                                     rollbackMessaggio.rollbackBustaIntoOutBox();
  821.                                     ((StateMessage)openspcoopstate.getStatoRichiesta()).executePreparedStatement();
  822.     
  823.                                     // ollback jms receiver
  824.                                     if(receiverJMS!=null){
  825.                                         String rifMsg = gestoreMsg.getRiferimentoMessaggio();
  826.                                         if(rifMsg!=null){
  827.                                             // rollback jms receiver
  828.                                             String strMessageSelector = "ID = '"+rifMsg+"'";
  829.                                             if (receiverJMS.clean(RicezioneBuste.ID_MODULO,strMessageSelector)){
  830.                                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_CODA_JMS_FILTRO_MSG_DA_ELIMINARE,
  831.                                                         RicezioneBuste.ID_MODULO);
  832.                                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_RICERCA_MSG_DA_ELIMINARE_PER_RIFERIMENTO,"false");
  833.                                                 this.msgDiag.logPersonalizzato("messaggioNonConsumato.codaJMS");
  834.                                             }
  835.                                         }
  836.                                     }
  837.     
  838.                                     //  eliminazione messaggio
  839.                                     if(this.propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  840.                                         gestoreMsg._deleteMessageWithoutLock();
  841.                                     }
  842.                                     else {
  843.                                         gestoreMsg.deleteMessageByOraRegistrazione(now);
  844.                                     }
  845.     
  846.                                     this.msgDiag.logPersonalizzato("eliminazioneMessaggio");
  847.                                     if(this.logQuery)
  848.                                         this.logTimer.debug(this.msgDiag.getMessaggio_replaceKeywords("eliminazioneMessaggio"));
  849.     
  850.                                     gestiti++;
  851.     
  852.                                 }catch(Exception e){
  853.                                     if(rollbackMessaggio!=null){
  854.                                         ((StateMessage)openspcoopstate.getStatoRichiesta()).closePreparedStatement();
  855.                                         rollbackMessaggio = null;
  856.                                     }
  857.                                     this.msgDiag.logErroreGenerico(e,"EliminazioneMessaggioRicezioneBusteNonGestiti("+idMsgDaEliminare+")");
  858.                                     this.logTimer.error("ErroreEliminazioneMessaggioRicezioneBusteNonGestiti("+idMsgDaEliminare+"): "+e.getMessage(),e);
  859.                                 }
  860.                             }
  861.     
  862.                             if(this.logQuery)
  863.                                 this.logTimer.info("Eliminati "+gestiti+" messaggi (non gestiti da 'RicezioneBuste') nel repository (OUTBOX)");
  864.     
  865.                         }
  866.                         else{
  867.                             if(this.logQuery)
  868.                                 this.logTimer.info("Non sono stati trovati messaggi (non gestiti da 'RicezioneBuste') da eliminare nel repository (OUTBOX)");
  869.                         }
  870.                     }finally{
  871.                         try{
  872.                             GestoreMessaggi.releaseLock(
  873.                                     this.semaphore, connectionDB, this.timerLock,
  874.                                     this.msgDiag, causaMessaggiOUTBOXNonGestitiRicezioneBuste);
  875.                         }catch(Exception e){
  876.                             // ignore
  877.                         }
  878.                     }
  879.                     
  880.                 }
  881.                 else {
  882.                     if(this.logQuery) {
  883.                         this.logTimer.info("Gestione messaggi (non gestiti) disabilitata");
  884.                     }   
  885.                 }
  886.                 
  887.                 

  889.                 // log finale  
  890.                 if(trovatiMessaggi){
  891.                     this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_NUM_MSG_INBOX_COMPLETATI, idMsgInutiliINBOX!=null ? idMsgInutiliINBOX.size()+"" : 0+"");
  892.                     this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_NUM_MSG_OUTBOX_COMPLETATI, idMsgInutiliOUTBOX!=null ? idMsgInutiliOUTBOX.size()+"" : 0+"");
  893.                     this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_NUM_MSG_INBOX_SCADUTI, idMsgScadutiINBOX!=null ? idMsgScadutiINBOX.size()+"" : 0+"");
  894.                     this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_NUM_MSG_OUTBOX_SCADUTI, idMsgScadutiOUTBOX!=null ? idMsgScadutiOUTBOX.size()+"" : 0+"");
  895.                     this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_NUM_MSG_NON_GESTITI_RICEZIONE_CONTENUTI_APPLICATIVI, 
  896.                             idMsgServizioRicezioneContenutiApplicativiNonGestiti!=null ? idMsgServizioRicezioneContenutiApplicativiNonGestiti.size()+"" : 0+"");
  897.                     this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_NUM_MSG_NON_GESTITI_RICEZIONE_BUSTE, 
  898.                             idMsgServizioRicezioneBusteNonGestiti!=null ? idMsgServizioRicezioneBusteNonGestiti.size()+"" : 0+"");
  899.                     this.msgDiag.logPersonalizzato("ricercaMessaggiDaEliminare");
  900.                 }

  902.             }







  910.             if(TimerState.ENABLED.equals(STATE_CORRELAZIONE_APPLICATIVA)) {

  912.                 //  CorrelazioniApplicative da eliminare
  913.                 GestoreCorrelazioneApplicativaConfig caConfig = new GestoreCorrelazioneApplicativaConfig();
  914.                 caConfig.setState(openspcoopstate.getStatoRichiesta());
  915.                 caConfig.setAlog(this.logTimer);
  916.                 GestoreCorrelazioneApplicativa gestoreCorrelazioneApplicativa = new GestoreCorrelazioneApplicativa(caConfig);
  917.     
  918.     
  919.                 // -- Scadute (Correlazioni per cui era stata impostata una scadenza) --
  920.                 String causaCorrelazioniApplicativeScadute = "Eliminazione correlazioni applicative scadute";
  921.                 List<Long> correlazioniScadute;
  922.                 try{
  923.                     GestoreMessaggi.acquireLock(
  924.                             this.semaphore, connectionDB, this.timerLockCorrelazioneApplicativa,
  925.                             this.msgDiag, causaCorrelazioniApplicativeScadute, 
  926.                             this.propertiesReader.getGestioneSerializableDBAttesaAttiva(), 
  927.                             this.propertiesReader.getGestioneSerializableDBCheckInterval());
  928.     
  929.                     correlazioniScadute = gestoreCorrelazioneApplicativa.getCorrelazioniScadute(this.limit,this.logQuery,this.orderByQuery);
  930.                     this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_TIPO_RICERCA_MSG_DA_ELIMINARE,"CorrelazioniApplicative");
  931.                     if(this.logQuery){
  932.                         if(correlazioniScadute.size()<=0){
  933.                             this.logTimer.info("Non sono state trovate correlazioni applicative (scadute) da eliminare");
  934.                         }
  935.                     }
  936.     
  937.                     while(correlazioniScadute.size()>0){
  938.     
  939.                         if(this.logQuery)
  940.                             this.logTimer.info("Trovate "+correlazioniScadute.size()+" correlazioni applicative (scadute) da eliminare ...");
  941.     
  942.                         this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_NUM_CORRELAZIONI_APPLICATIVE_SCADUTE, correlazioniScadute.size()+"");
  943.                         this.msgDiag.logPersonalizzato("ricercaCorrelazioniApplicativeScadute");
  944.     
  945.                         int gestiti = 0;
  946.                         while(correlazioniScadute.size()>0){
  947.                             Long idCorrelazioneScaduta = correlazioniScadute.remove(0);
  948.     
  949.                             String idCorrelato = null;
  950.                             String idApplicativo = null;
  951.     
  952.                             try{    
  953.                                 String [] id = gestoreCorrelazioneApplicativa.getIDMappingCorrelazioneApplicativa(idCorrelazioneScaduta);
  954.                                 idCorrelato = id[0];
  955.                                 idApplicativo = id[1];
  956.                                 try{
  957.                                     GestoreMessaggi.updateLock(
  958.                                             this.semaphore, connectionDB, this.timerLockCorrelazioneApplicativa,
  959.                                             this.msgDiag, "Eliminazione correlazione applicativa scaduta (id_applicativo:"+idApplicativo+",id_busta:"+idCorrelato+") ...");
  960.                                 }catch(Throwable e){
  961.                                     this.msgDiag.logErroreGenerico(e,"EliminazioneCorrelazioni(id_applicativo:"+idApplicativo+",id_busta:"+idCorrelato+")-UpdateLock");
  962.                                     this.logTimer.error("ErroreEliminazioneCorrelazioni(id_applicativo:"+idApplicativo+",id_busta:"+idCorrelato+")-UpdateLock: "+e.getMessage(),e);
  963.                                     break;
  964.                                 }
  965.     
  966.                                 this.msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_DA_ELIMINARE,idCorrelato);
  967.                                 this.msgDiag.addKeyword(CostantiPdD.KEY_ID_CORRELAZIONE_APPLICATIVA,idApplicativo);
  968.     
  969.                                 gestoreCorrelazioneApplicativa.deleteCorrelazioneApplicativa(idCorrelazioneScaduta);
  970.                                 this.msgDiag.logPersonalizzato("eliminazioneCorrelazioneApplicativaScaduta");
  971.                                 if(this.logQuery)
  972.                                     this.logTimer.debug(this.msgDiag.getMessaggio_replaceKeywords("eliminazioneCorrelazioneApplicativaScaduta"));
  973.     
  974.                                 gestiti++;
  975.     
  976.                             }catch(Exception e){
  977.                                 this.msgDiag.logErroreGenerico(e,"EliminazioneCorrelazioni(id_applicativo:"+idApplicativo+",id_busta:"+idCorrelato+")");
  978.                                 this.logTimer.error("ErroreEliminazioneCorrelazioni(id_applicativo:"+idApplicativo+",id_busta:"+idCorrelato+"): "+e.getMessage(),e);
  979.                             }
  980.                         }
  981.     
  982.                         if(this.logQuery)
  983.                             this.logTimer.info("Eliminate "+gestiti+" correlazioni applicative (scadute)");
  984.     
  985.                         boolean cerca = true;
  986.                         try{
  987.                             GestoreMessaggi.updateLock(
  988.                                     this.semaphore, connectionDB, this.timerLockCorrelazioneApplicativa,
  989.                                     this.msgDiag, "Ricerca nuove correlazioni scadute  ...");
  990.                         }catch(Throwable e){
  991.                             this.msgDiag.logErroreGenerico(e,"RicercaNuoveCorrelazioni-UpdateLock");
  992.                             this.logTimer.error("RicercaNuoveCorrelazioni-UpdateLock: "+e.getMessage(),e);
  993.                             cerca = false;
  994.                         }
  995.                         
  996.                         if(cerca) {
  997.                             // Check altre correlazioni da eliminare
  998.                             correlazioniScadute = gestoreCorrelazioneApplicativa.getCorrelazioniScadute(this.limit,this.logQuery,this.orderByQuery);
  999.                         }
  1000.                         else {
  1001.                             correlazioniScadute = new java.util.ArrayList<Long>(); // per uscire dal while
  1002.                         }
  1003.                     }
  1004.                 }finally{
  1005.                     try{
  1006.                         GestoreMessaggi.releaseLock(
  1007.                                 this.semaphore, connectionDB, this.timerLockCorrelazioneApplicativa,
  1008.                                 this.msgDiag, causaCorrelazioniApplicativeScadute);
  1009.                     }catch(Exception e){
  1010.                         // ignore
  1011.                     }
  1012.                 }
  1013.     
  1014.     
  1015.                 // -- Scadute rispetto ora registrazione
  1016.                 if(this.filtraCorrelazioniApplicativeScaduteRispettoOraRegistrazione){
  1017.                     String causaCorrelazioniApplicativeScaduteRispettoOraRegistrazione = "Eliminazione correlazioni applicative scadute rispetto ora registrazione";
  1018.                     List<Long> correlazioniScaduteRispettoOraRegistrazione = null; 
  1019.                     try{
  1020.                         GestoreMessaggi.acquireLock(
  1021.                                 this.semaphore, connectionDB, this.timerLockCorrelazioneApplicativa,
  1022.                                 this.msgDiag, causaCorrelazioniApplicativeScaduteRispettoOraRegistrazione, 
  1023.                                 this.propertiesReader.getGestioneSerializableDBAttesaAttiva(), 
  1024.                                 this.propertiesReader.getGestioneSerializableDBCheckInterval());
  1025.     
  1026.                         correlazioniScaduteRispettoOraRegistrazione = gestoreCorrelazioneApplicativa.getCorrelazioniScaduteRispettoOraRegistrazione(this.limit, this.scadenzaCorrelazioneApplicativa, 
  1027.                                 this.logQuery,this.orderByQuery,this.filtraCorrelazioniApplicativeScaduteRispettoOraRegistrazione_escludiCorrelazioniConScadenzaImpostata);
  1028.                         if(this.logQuery){
  1029.                             if(correlazioniScaduteRispettoOraRegistrazione.size()<=0){
  1030.                                 this.logTimer.info("Non sono state trovate correlazioni applicative (scadute rispetto ora registrazione) da eliminare");
  1031.                             }
  1032.                         }
  1033.                         while(correlazioniScaduteRispettoOraRegistrazione.size()>0){
  1034.     
  1035.                             if(this.logQuery)
  1036.                                 this.logTimer.info("Trovate "+correlazioniScaduteRispettoOraRegistrazione.size()+" correlazioni applicative (scadute rispetto ora registrazione) da eliminare ...");
  1037.     
  1038.                             this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_NUM_CORRELAZIONI_APPLICATIVE_SCADUTE, correlazioniScaduteRispettoOraRegistrazione.size()+"");
  1039.                             this.msgDiag.logPersonalizzato("ricercaCorrelazioniApplicativeScaduteRispettoOraRegistrazione");
  1040.     
  1041.                             int gestiti = 0;
  1042.                             while(correlazioniScaduteRispettoOraRegistrazione.size()>0){
  1043.                                 Long idCorrelazioneScaduta = correlazioniScaduteRispettoOraRegistrazione.remove(0);
  1044.     
  1045.                                 String idCorrelato = null;
  1046.                                 String idApplicativo = null;
  1047.     
  1048.                                 try{
  1049.                                     String [] id = gestoreCorrelazioneApplicativa.getIDMappingCorrelazioneApplicativa(idCorrelazioneScaduta);
  1050.                                     idCorrelato = id[0];
  1051.                                     idApplicativo = id[1];
  1052.                                     try{
  1053.                                         GestoreMessaggi.updateLock(
  1054.                                                 this.semaphore, connectionDB, this.timerLockCorrelazioneApplicativa,
  1055.                                                 this.msgDiag, "Eliminazione correlazione applicativa scaduta rispetto ora registrazione (id_applicativo:"+idApplicativo+",id_busta:"+idCorrelato+") ...");
  1056.                                     }catch(Throwable e){
  1057.                                         this.msgDiag.logErroreGenerico(e,"EliminazioneCorrelazioniRispettoOraRegistrazione(id_applicativo:"+idApplicativo+",id_busta:"+idCorrelato+")-UpdateLock");
  1058.                                         this.logTimer.error("ErroreEliminazioneCorrelazioniRispettoOraRegistrazione(id_applicativo:"+idApplicativo+",id_busta:"+idCorrelato+")-UpdateLock: "+e.getMessage(),e);
  1059.                                         break;
  1060.                                     }
  1061.     
  1062.                                     this.msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_DA_ELIMINARE,idCorrelato);
  1063.                                     this.msgDiag.addKeyword(CostantiPdD.KEY_ID_CORRELAZIONE_APPLICATIVA,idApplicativo);
  1064.     
  1065.                                     gestoreCorrelazioneApplicativa.deleteCorrelazioneApplicativa(idCorrelazioneScaduta);
  1066.                                     this.msgDiag.logPersonalizzato("eliminazioneCorrelazioneApplicativaScaduta");
  1067.                                     if(this.logQuery)
  1068.                                         this.logTimer.debug(this.msgDiag.getMessaggio_replaceKeywords("eliminazioneCorrelazioneApplicativaScaduta"));
  1069.     
  1070.                                     gestiti++;
  1071.                                     
  1072.                                 }catch(Exception e){
  1073.                                     this.msgDiag.logErroreGenerico(e,"EliminazioneCorrelazioniRispettoOraRegistrazione(id_applicativo:"+idApplicativo+",id_busta:"+idCorrelato+")");
  1074.                                     this.logTimer.error("ErroreEliminazioneCorrelazioniRispettoOraRegistrazione(id_applicativo:"+idApplicativo+",id_busta:"+idCorrelato+"): "+e.getMessage(),e);
  1075.                                 }
  1076.                             }
  1077.     
  1078.                             if(this.logQuery)
  1079.                                 this.logTimer.info("Eliminate "+gestiti+" correlazioni applicative (scadute rispetto ora registrazione)");
  1080.     
  1081.                             boolean cerca = true;
  1082.                             try{
  1083.                                 GestoreMessaggi.updateLock(
  1084.                                         this.semaphore, connectionDB, this.timerLockCorrelazioneApplicativa,
  1085.                                         this.msgDiag, "Ricerca nuove correlazioni scadute rispetto ora registrazione ...");                                                 
  1086.                             }catch(Throwable e){
  1087.                                 this.msgDiag.logErroreGenerico(e,"RicercaNuoveCorrelazioni-UpdateLock");
  1088.                                 this.logTimer.error("RicercaNuoveCorrelazioni-UpdateLock: "+e.getMessage(),e);
  1089.                                 cerca = false;
  1090.                             }
  1091.                             
  1092.                             if(cerca) {
  1093.                                 // Check altre correlazioni da eliminare
  1094.                                 correlazioniScaduteRispettoOraRegistrazione = 
  1095.                                         gestoreCorrelazioneApplicativa.getCorrelazioniScaduteRispettoOraRegistrazione(this.limit, this.scadenzaCorrelazioneApplicativa, 
  1096.                                                 this.logQuery,this.orderByQuery,this.filtraCorrelazioniApplicativeScaduteRispettoOraRegistrazione_escludiCorrelazioniConScadenzaImpostata);
  1097.                             }
  1098.                             else {
  1099.                                 correlazioniScaduteRispettoOraRegistrazione = new java.util.ArrayList<Long>(); // per uscire dal while
  1100.                             }
  1101.                         }
  1102.                     }finally{
  1103.                         try{
  1104.                             GestoreMessaggi.releaseLock(
  1105.                                     this.semaphore, connectionDB, this.timerLockCorrelazioneApplicativa,
  1106.                                     this.msgDiag, causaCorrelazioniApplicativeScaduteRispettoOraRegistrazione);
  1107.                         }catch(Exception e){
  1108.                             // ignore
  1109.                         }
  1110.                     }
  1111.                 }
  1112.             }
  1113.             else {
  1114.                 if(this.logQuery) {
  1115.                     this.logTimer.info("Gestione correlazione applicativa disabilitata");
  1116.                 }   
  1117.             }


  1120.             // end
  1121.             long endControlloRepositoryMessaggi = DateManager.getTimeMillis();
  1122.             long diff = (endControlloRepositoryMessaggi-startControlloRepositoryMessaggi);
  1123.             this.logTimer.info("Controllo Repository Messaggi terminato in "+Utilities.convertSystemTimeIntoStringMillisecondi(diff, true));

  1125.         } 
  1126.         catch(TimerLockNotAvailableException t) {
  1127.             // msg diagnostico emesso durante l'emissione dell'eccezione
  1128.             this.logTimer.info(t.getMessage(),t);
  1129.         }
  1130.         catch (Exception e) {
  1131.             this.msgDiag.logErroreGenerico(e,"GestioneMessaggi");
  1132.             this.logTimer.error("Riscontrato errore durante la gestione del repository dei messaggi: "+ e.getMessage(),e);
  1133.         }finally{
  1134.             if(openspcoopstate!=null)
  1135.                 openspcoopstate.releaseResource();
  1136.         }


  1139.         try {
  1140.             if(TimerState.ENABLED.equals(STATE_VERIFICA_CONNESSIONI_ATTIVE)) {

  1142.                 startControlloRepositoryMessaggi = DateManager.getTimeMillis();
  1143.                 this.logTimer.info("Verifico connessioni attive...");

  1145.                 // Connettori: porta delegata
  1146.                 List<String> identificatoriConnettoriPD = RepositoryConnettori.getIdentificatoriConnettori_pd();
  1147.                 if(this.logQuery){
  1148.                     if(identificatoriConnettoriPD==null || identificatoriConnettoriPD.isEmpty()){
  1149.                         this.logTimer.info("Non sono state trovate connessioni attive sulle PorteDelegate");
  1150.                     }
  1151.                 }
  1152.                 if(identificatoriConnettoriPD!=null){

  1154.                     boolean verificaEffettuata = false;
  1155.                     if(this.logQuery){
  1156.                         if(!identificatoriConnettoriPD.isEmpty()){
  1157.                             this.logTimer.info("Sono state trovate connessioni attive sulle PorteDelegate, verifica in corso ...");
  1158.                         }
  1159.                     }

  1161.                     for (String identificatoreConnessione : identificatoriConnettoriPD) {
  1162.                         verificaEffettuata = true;
  1163.                         String tipoConnettore = null;
  1164.                         IConnettore connettore = null;
  1165.                         try{
  1166.                             connettore = RepositoryConnettori.getConnettorePD(identificatoreConnessione);
  1167.                             // puo' essere stato eliminato nel frattempo
  1168.                             if(connettore!=null){
  1169.                                 tipoConnettore = connettore.getClass().getSimpleName();
  1170.                             }
  1171.                             int millisecondiScadenza = this.propertiesReader.getConnectionLife_inoltroBuste();
  1172.                             Date now = DateManager.getDate();
  1173.                             Date scadenza = new Date(now.getTime()-millisecondiScadenza);
  1174.                             String tipoConnessione = "tipo:"+tipoConnettore+" porta:delegata id_busta:"+identificatoreConnessione;
  1175.                             this.logTimer.debug("--------------------------------------");
  1176.                             this.logTimer.debug(tipoConnessione);
  1177.                             this.logTimer.debug("SCADENZA ["+scadenza.toString()+"]   CONNETTORE ["+((connettore!=null && connettore.getCreationDate()!=null) ? connettore.getCreationDate().toString() : null)+"]");
  1178.                             if(connettore!=null && connettore.getCreationDate()!=null && connettore.getCreationDate().before(scadenza)){
  1179.                                 this.logTimer.info("SCADUTO");
  1180.                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_TIPO_CONNESSIONE,tipoConnessione);
  1181.                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_DATA_CREAZIONE_CONNESSIONE,connettore.getCreationDate().toString());
  1182.                                 this.msgDiag.logPersonalizzato("connessioneScaduta.EliminazioneInCorso");

  1184.                                 connettore = RepositoryConnettori.removeConnettorePD(identificatoreConnessione);
  1185.                                 if(connettore!=null){
  1186.                                     connettore.disconnect();
  1187.                                 }

  1189.                                 this.msgDiag.logPersonalizzato("connessioneScaduta.EliminazioneEffettuata");
  1190.                             }
  1191.                             else{
  1192.                                 if(connettore==null) {
  1193.                                     this.logTimer.debug("NON PIU' PRESENTE");
  1194.                                 }
  1195.                                 else if(connettore.getCreationDate()==null) {
  1196.                                     this.logTimer.debug("SENZA DATA DI CREAZIONE");
  1197.                                 }
  1198.                                 else {
  1199.                                     this.logTimer.debug("NON SCADUTO");
  1200.                                 }
  1201.                             }

  1203.                             this.logTimer.debug("--------------------------------------");

  1205.                         }catch(Exception e){
  1206.                             // non mi interessa gestire l'eventuale eccezione, a parte registrarla
  1207.                             if(tipoConnettore!=null){
  1208.                                 String msgErrore = "EliminazioneConnessione(tipo:"+tipoConnettore+" porta:delegata id_busta:"+identificatoreConnessione+")";
  1209.                                 this.msgDiag.logErroreGenerico(e,msgErrore);
  1210.                                 this.logTimer.error("Errore"+msgErrore+": "+e.getMessage(),e);
  1211.                             }
  1212.                             else{
  1213.                                 String msgErrore = "EliminazioneConnessione(porta:delegata id_busta:"+identificatoreConnessione+")";
  1214.                                 this.msgDiag.logErroreGenerico(e,msgErrore);
  1215.                                 this.logTimer.error("Errore"+msgErrore+": "+e.getMessage(),e);
  1216.                             }
  1217.                         }
  1218.                         catch(Throwable e){
  1219.                             // non mi interessa gestire l'eventuale eccezione, a parte registrarla
  1220.                             if(tipoConnettore!=null){
  1221.                                 String msgErrore = "EliminazioneConnessione(tipo:"+tipoConnettore+" porta:delegata id_busta:"+identificatoreConnessione+")";
  1222.                                 this.msgDiag.logErroreGenerico(e,msgErrore);
  1223.                                 this.logTimer.error("Errore"+msgErrore+": "+e.getMessage(),e);
  1224.                             }
  1225.                             else{
  1226.                                 String msgErrore = "EliminazioneConnessione(porta:delegata id_busta:"+identificatoreConnessione+")";
  1227.                                 this.msgDiag.logErroreGenerico(e,msgErrore);
  1228.                                 this.logTimer.error("Errore"+msgErrore+": "+e.getMessage(),e);
  1229.                             }
  1230.                         }
  1231.                     }

  1233.                     if(this.logQuery){
  1234.                         if(verificaEffettuata){
  1235.                             this.logTimer.info("Terminata verifica connessioni attive sulle PorteDelegate");
  1236.                         }
  1237.                     }
  1238.                 }


  1241.                 // Connettori: porta applicativa
  1242.                 List<String> identificatoriConnettoriPA = RepositoryConnettori.getIdentificatoriConnettori_pa();
  1243.                 if(this.logQuery){
  1244.                     if(identificatoriConnettoriPA==null || identificatoriConnettoriPA.isEmpty()==false){
  1245.                         this.logTimer.info("Non sono state trovate connessioni attive sulle PorteApplicative");
  1246.                     }
  1247.                 }
  1248.                 if(identificatoriConnettoriPA!=null){

  1250.                     boolean verificaEffettuata = false;
  1251.                     if(this.logQuery){
  1252.                         if(!identificatoriConnettoriPA.isEmpty()){
  1253.                             this.logTimer.info("Sono state trovate connessioni attive sulle PorteApplicative, verifica in corso ...");
  1254.                         }
  1255.                     }

  1257.                     for (String identificatoreConnessione : identificatoriConnettoriPA) {
  1258.                         verificaEffettuata = true;
  1259.                         String tipoConnettore = null;
  1260.                         IConnettore connettore = null;
  1261.                         try{
  1262.                             connettore = RepositoryConnettori.getConnettorePA(identificatoreConnessione);
  1263.                             // puo' essere stato eliminato nel frattempo
  1264.                             if(connettore!=null){
  1265.                                 tipoConnettore = connettore.getClass().getSimpleName();
  1266.                             }
  1267.                             int millisecondiScadenza = this.propertiesReader.getConnectionLife_consegnaContenutiApplicativi();
  1268.                             Date now = DateManager.getDate();
  1269.                             Date scadenza = new Date(now.getTime()-millisecondiScadenza);
  1270.                             String tipoConnessione = "tipo:"+tipoConnettore+" porta:applicativa id_busta:"+identificatoreConnessione;
  1271.                             this.logTimer.debug("--------------------------------------");
  1272.                             this.logTimer.debug(tipoConnessione);
  1273.                             this.logTimer.debug("SCADENZA ["+scadenza.toString()+"]   CONNETTORE ["+((connettore!=null && connettore.getCreationDate()!=null) ? connettore.getCreationDate().toString() : null)+"]");
  1274.                             if(connettore!=null && connettore.getCreationDate()!=null && connettore.getCreationDate().before(scadenza)){
  1275.                                 this.logTimer.info("SCADUTO");
  1276.                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_TIPO_CONNESSIONE,tipoConnessione);
  1277.                                 this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_DATA_CREAZIONE_CONNESSIONE,connettore.getCreationDate().toString());
  1278.                                 this.msgDiag.logPersonalizzato("connessioneScaduta.EliminazioneInCorso");

  1280.                                 connettore = RepositoryConnettori.removeConnettorePA(identificatoreConnessione);
  1281.                                 if(connettore!=null){
  1282.                                     connettore.disconnect();
  1283.                                 }

  1285.                                 this.msgDiag.logPersonalizzato("connessioneScaduta.EliminazioneEffettuata");
  1286.                             }
  1287.                             else{
  1288.                                 if(connettore==null) {
  1289.                                     this.logTimer.debug("NON PIU' PRESENTE");
  1290.                                 }
  1291.                                 else if(connettore.getCreationDate()==null) {
  1292.                                     this.logTimer.debug("SENZA DATA DI CREAZIONE");
  1293.                                 }
  1294.                                 else {
  1295.                                     this.logTimer.debug("NON SCADUTO");
  1296.                                 }
  1297.                             }

  1299.                             this.logTimer.debug("--------------------------------------");

  1301.                         }catch(Exception e){
  1302.                             // non mi interessa gestire l'eventuale eccezione, a parte registrarla
  1303.                             if(tipoConnettore!=null){
  1304.                                 String msgErrore = "EliminazioneConnessione(tipo:"+tipoConnettore+" porta:applicativa id_busta:"+identificatoreConnessione+")";
  1305.                                 this.msgDiag.logErroreGenerico(e,msgErrore);
  1306.                                 this.logTimer.error("Errore"+msgErrore+": "+e.getMessage(),e);
  1307.                             }
  1308.                             else{
  1309.                                 String msgErrore = "EliminazioneConnessione(porta:applicativa id_busta:"+identificatoreConnessione+")";
  1310.                                 this.msgDiag.logErroreGenerico(e,msgErrore);
  1311.                                 this.logTimer.error("Errore"+msgErrore+": "+e.getMessage(),e);
  1312.                             }
  1313.                         }
  1314.                         catch(Throwable e){
  1315.                             // non mi interessa gestire l'eventuale eccezione, a parte registrarla
  1316.                             if(tipoConnettore!=null){
  1317.                                 String msgErrore = "EliminazioneConnessione(tipo:"+tipoConnettore+" porta:applicativa id_busta:"+identificatoreConnessione+")";
  1318.                                 this.msgDiag.logErroreGenerico(e,msgErrore);
  1319.                                 this.logTimer.error("Errore"+msgErrore+": "+e.getMessage(),e);
  1320.                             }   
  1321.                             else{
  1322.                                 String msgErrore = "EliminazioneConnessione(porta:applicativa id_busta:"+identificatoreConnessione+")";
  1323.                                 this.msgDiag.logErroreGenerico(e,msgErrore);
  1324.                                 this.logTimer.error("Errore"+msgErrore+": "+e.getMessage(),e);
  1325.                             }
  1326.                         }
  1327.                     }

  1329.                     if(this.logQuery){
  1330.                         if(verificaEffettuata){
  1331.                             this.logTimer.info("Terminata verifica connessioni attive sulle PorteApplicative");
  1332.                         }
  1333.                     }


  1336.                 }

  1338.                 // end
  1339.                 long endControlloRepositoryMessaggi = DateManager.getTimeMillis();
  1340.                 long diff = (endControlloRepositoryMessaggi-startControlloRepositoryMessaggi);
  1341.                 this.logTimer.info("Terminata verifica connessioni attive in "+Utilities.convertSystemTimeIntoStringMillisecondi(diff, true));
  1342.             }
  1343.             else{
  1344.                 this.logTimer.warn("Non verifico connessioni attive");
  1345.             }

  1347.         } 
  1348.         catch (Exception e) {
  1349.             this.msgDiag.logErroreGenerico(e,"GestioneMessaggi");
  1350.             this.logTimer.error("Riscontrato errore durante la gestione del repository dei messaggi: "+ e.getMessage(),e);
  1351.         }
  1352.     }

  1354. }
Created with JaCoCo 0.8.8.202204050719