TimerGestorePuliziaMessaggiAnomaliLib.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.ArrayList;
  27. import java.util.List;

  29. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  30. import org.openspcoop2.pdd.core.CostantiPdD;
  31. import org.openspcoop2.pdd.core.GestoreMessaggi;
  32. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  33. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  34. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  35. import org.openspcoop2.protocol.engine.constants.Costanti;
  36. import org.openspcoop2.protocol.engine.driver.RollbackRepositoryBuste;
  37. import org.openspcoop2.protocol.sdk.state.StateMessage;
  38. import org.openspcoop2.utils.TipiDatabase;
  39. import org.openspcoop2.utils.Utilities;
  40. import org.openspcoop2.utils.date.DateManager;
  41. import org.openspcoop2.utils.id.serial.InfoStatistics;
  42. import org.openspcoop2.utils.semaphore.Semaphore;
  43. import org.openspcoop2.utils.semaphore.SemaphoreConfiguration;
  44. import org.openspcoop2.utils.semaphore.SemaphoreMapping;
  45. import org.slf4j.Logger;

  47. /**
  48.  * Implementazione dell'interfaccia {@link TimerGestorePuliziaMessaggiAnomali} del Gestore
  49.  * dei threads di servizio di OpenSPCoop.
  50.  * 
  51.  *  
  52.  * @author Poli Andrea (apoli@link.it)
  53.  * @author $Author$
  54.  * @version $Rev$, $Date$
  55.  */

  57. public class TimerGestorePuliziaMessaggiAnomaliLib{

  59.     private static TimerState STATE = TimerState.OFF; // abilitato in OpenSPCoop2Startup al momento dell'avvio
  60.     
  61.     public static TimerState getSTATE() {
  62.         return STATE;
  63.     }
  64.     public static void setSTATE(TimerState sTATE) {
  65.         STATE = sTATE;
  66.     }

  68.     private MsgDiagnostico msgDiag = null;
  69.     private Logger logTimer = null;
  70.     private OpenSPCoop2Properties propertiesReader = null;
  71.     private boolean logQuery = false;
  72.     private int limit = CostantiPdD.LIMIT_MESSAGGI_GESTORI;
  73.     private boolean orderByQuery;

  75.     private TimerLock timerLock = null;

  77.     /** Semaforo */
  78.     private Semaphore semaphore = null;
  79.     private InfoStatistics semaphore_statistics;

  81.     public TimerGestorePuliziaMessaggiAnomaliLib(MsgDiagnostico msgDiag,Logger log,OpenSPCoop2Properties p,boolean logQuery,
  82.             int limit,boolean orderByQuery) throws TimerException{
  83.         this.msgDiag = msgDiag;
  84.         this.logTimer = log;
  85.         this.propertiesReader = p;
  86.         this.logQuery = logQuery;
  87.         this.limit = limit;
  88.         this.orderByQuery = orderByQuery;
  89.         
  90.         this.timerLock = new TimerLock(TipoLock.GESTIONE_PULIZIA_MESSAGGI_ANOMALI);

  92.         if(this.propertiesReader.isTimerLockByDatabase()) {
  93.             this.semaphore_statistics = new InfoStatistics();

  95.             SemaphoreConfiguration config = GestoreMessaggi.newSemaphoreConfiguration(this.propertiesReader.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife(), 
  96.                     this.propertiesReader.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime());

  98.             TipiDatabase databaseType = TipiDatabase.toEnumConstant(this.propertiesReader.getDatabaseType());
  99.             try {
  100.                 this.semaphore = new Semaphore(this.semaphore_statistics, SemaphoreMapping.newInstance(this.timerLock.getIdLock()), 
  101.                         config, databaseType, this.logTimer);
  102.             }catch(Exception e) {
  103.                 throw new TimerException(e.getMessage(),e);
  104.             }
  105.         }
  106.     }

  108.     public void check() throws TimerException {

  110.         // Controllo che il sistema non sia andando in shutdown
  111.         if(OpenSPCoop2Startup.contextDestroyed){
  112.             this.logTimer.error("["+TimerGestorePuliziaMessaggiAnomali.ID_MODULO+"] Rilevato sistema in shutdown");
  113.             return;
  114.         }

  116.         // Controllo che l'inizializzazione corretta delle risorse sia effettuata
  117.         if(!OpenSPCoop2Startup.initialize){
  118.             this.msgDiag.logFatalError("inizializzazione di OpenSPCoop non effettuata", "Check Inizializzazione");
  119.             String msgErrore = "Riscontrato errore: inizializzazione del Timer o di OpenSPCoop non effettuata";
  120.             this.logTimer.error(msgErrore);
  121.             throw new TimerException(msgErrore);
  122.         }

  124.         // Controllo risorse di sistema disponibili
  125.         if( !TimerMonitoraggioRisorseThread.isRisorseDisponibili()){
  126.             this.logTimer.error("["+TimerGestorePuliziaMessaggiAnomali.ID_MODULO+"] Risorse di sistema non disponibili: "+TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile().getMessage(),TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile());
  127.             return;
  128.         }
  129.         if( !MsgDiagnostico.gestoreDiagnosticaDisponibile){
  130.             this.logTimer.error("["+TimerGestorePuliziaMessaggiAnomali.ID_MODULO+"] Sistema di diagnostica non disponibile: "+MsgDiagnostico.motivoMalfunzionamentoDiagnostici.getMessage(),MsgDiagnostico.motivoMalfunzionamentoDiagnostici);
  131.             return;
  132.         }
  133.         
  134.         // Controllo che il timer non sia stato momentaneamente disabilitato
  135.         if(!TimerState.ENABLED.equals(STATE)) {
  136.             this.msgDiag.logPersonalizzato("disabilitato");
  137.             this.logTimer.info(this.msgDiag.getMessaggio_replaceKeywords("disabilitato"));
  138.             return;
  139.         }


  142.         this.msgDiag.logPersonalizzato("controlloInCorso");
  143.         this.logTimer.info(this.msgDiag.getMessaggio_replaceKeywords("controlloInCorso"));
  144.         long startControlloRepositoryMessaggi = DateManager.getTimeMillis();


  147.         RollbackRepositoryBuste rollbackMessaggio = null;

  149.         OpenSPCoopStateful openspcoopstate = new OpenSPCoopStateful();

  151.         try {

  153.             openspcoopstate.initResource(this.propertiesReader.getIdentitaPortaDefaultWithoutProtocol(), TimerGestorePuliziaMessaggiAnomali.ID_MODULO, null);
  154.             Connection connectionDB = ((StateMessage)openspcoopstate.getStatoRichiesta()).getConnectionDB();
  155.             

  157.             // Messaggi da eliminare 
  158.             GestoreMessaggi gestoreMsgSearch = new GestoreMessaggi(openspcoopstate, true,this.logTimer, this.msgDiag,null);
  159.             String causaMessaggiDaRipulire = "Eliminazione buste non più riferite da messaggi";
  160.             List<String> busteInutiliINBOX = null;
  161.             List<String> busteInutiliOUTBOX = null;
  162.             try{
  163.                 GestoreMessaggi.acquireLock(
  164.                         this.semaphore, connectionDB, this.timerLock,
  165.                         this.msgDiag, causaMessaggiDaRipulire, 
  166.                         this.propertiesReader.getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva(), 
  167.                         this.propertiesReader.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval());
  168.                 
  169.                 busteInutiliINBOX = gestoreMsgSearch.readBusteNonRiferiteDaMessaggiFromInBox(this.limit,this.logQuery,
  170.                         this.propertiesReader.isForceIndex(),this.orderByQuery);
  171.                 busteInutiliOUTBOX = gestoreMsgSearch.readBusteNonRiferiteDaMessaggiFromOutBox(this.limit,this.logQuery,
  172.                         this.propertiesReader.isForceIndex(),this.orderByQuery);
  173.     
  174.                 if(this.logQuery){
  175.                     if( ! (busteInutiliINBOX.size()>0 ||   busteInutiliOUTBOX.size() > 0)){
  176.                         this.logTimer.info("Non sono stati trovati messaggi anomali");
  177.                     }
  178.                 }
  179.     
  180.     
  181.                 while( busteInutiliINBOX.size()>0 ||
  182.                         busteInutiliOUTBOX.size() > 0){
  183.     
  184.                     this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_INCONSISTENTI_NUM_MSG_INBOX, busteInutiliINBOX.size()+"");
  185.                     this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_INCONSISTENTI_NUM_MSG_OUTBOX, busteInutiliOUTBOX.size()+"");
  186.     
  187.                     this.msgDiag.logPersonalizzato("ricercaMessaggiDaEliminare");
  188.     
  189.     
  190.                     // Buste non piu' riferite da messaggi
  191.                     // Eliminazione Messaggi from INBOX
  192.                     if(this.logQuery)
  193.                         this.logTimer.info("Trovate "+busteInutiliINBOX.size()+" buste non piu' riferita da messaggi da eliminare (INBOX) ...");
  194.                     this.msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO,Costanti.INBOX);
  195.                     for(int i=0; i<busteInutiliINBOX.size(); i++){
  196.     
  197.                         String idMsgDaEliminare = busteInutiliINBOX.get(i);
  198.                         this.msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_DA_ELIMINARE,idMsgDaEliminare);
  199.     
  200.                         try{
  201.                             GestoreMessaggi.updateLock(
  202.                                     this.semaphore, connectionDB, this.timerLock,
  203.                                     this.msgDiag, "Eliminazione busta anomala in INBOX con id ["+idMsgDaEliminare+"] ...");
  204.                         }catch(Throwable e){
  205.                             this.msgDiag.logErroreGenerico(e,"EliminazioneBustaInbox("+idMsgDaEliminare+")-UpdateLock");
  206.                             this.logTimer.error("ErroreEliminazioneBustaInbox("+idMsgDaEliminare+")-UpdateLock: "+e.getMessage(),e);
  207.                             break;
  208.                         }
  209.                         
  210.                         try{
  211.                             //  rollback messaggio scaduto (eventuale profilo + accesso_pdd)
  212.                             rollbackMessaggio = new RollbackRepositoryBuste(idMsgDaEliminare,openspcoopstate.getStatoRichiesta(),true);
  213.                             rollbackMessaggio.rollbackBustaIntoInBox(false); //l'history viene eliminato con la scadenza della busta
  214.                             ((StateMessage)openspcoopstate.getStatoRichiesta()).executePreparedStatement();
  215.     
  216.                             this.msgDiag.logPersonalizzato("eliminazioneMessaggio");
  217.                             if(this.logQuery){
  218.                                 this.logTimer.debug(this.msgDiag.getMessaggio_replaceKeywords("eliminazioneMessaggio"));
  219.                             }
  220.     
  221.                         }catch(Exception e){
  222.                             if(rollbackMessaggio!=null){
  223.                                 ((StateMessage)openspcoopstate.getStatoRichiesta()).closePreparedStatement();
  224.                                 rollbackMessaggio = null;
  225.                             }
  226.                             this.msgDiag.logErroreGenerico(e,"EliminazioneBustaInbox("+idMsgDaEliminare+")");
  227.                             this.logTimer.error("ErroreEliminazioneBustaInbox("+idMsgDaEliminare+"): "+e.getMessage(),e);
  228.                         }
  229.                     }
  230.                     if(this.logQuery)
  231.                         this.logTimer.info("Eliminate "+busteInutiliINBOX.size()+" buste non piu' riferita da messaggi (INBOX)");
  232.     
  233.     
  234.                     // Buste non piu' riferite da messaggi
  235.                     // Eliminazione Messaggi from OUTBOX
  236.                     if(this.logQuery)
  237.                         this.logTimer.info("Trovate "+busteInutiliOUTBOX.size()+" buste non piu' riferita da messaggi da eliminare (OUTBOX) ...");
  238.                     this.msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO,Costanti.OUTBOX);
  239.                     for(int i=0; i<busteInutiliOUTBOX.size(); i++){
  240.     
  241.                         String idMsgDaEliminare = busteInutiliOUTBOX.get(i);
  242.                         this.msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_DA_ELIMINARE,idMsgDaEliminare);
  243.     
  244.                         try{
  245.                             GestoreMessaggi.updateLock(
  246.                                     this.semaphore, connectionDB, this.timerLock,
  247.                                     this.msgDiag, "Eliminazione busta anomala in OUTBOX con id ["+idMsgDaEliminare+"] ...");
  248.                         }catch(Throwable e){
  249.                             this.msgDiag.logErroreGenerico(e,"EliminazioneBustaOutbox("+idMsgDaEliminare+")-UpdateLock");
  250.                             this.logTimer.error("EliminazioneBustaOutbox("+idMsgDaEliminare+")-UpdateLock: "+e.getMessage(),e);
  251.                             break;
  252.                         }
  253.                         
  254.                         try{
  255.                             //  rollback messaggio scaduto (eventuale profilo + accesso_pdd)
  256.                             rollbackMessaggio = new RollbackRepositoryBuste(idMsgDaEliminare,openspcoopstate.getStatoRichiesta(),true);
  257.                             rollbackMessaggio.rollbackBustaIntoOutBox(false); //l'history viene eliminato con la scadenza della busta
  258.                             ((StateMessage)openspcoopstate.getStatoRichiesta()).executePreparedStatement();
  259.     
  260.                             this.msgDiag.logPersonalizzato("eliminazioneMessaggio");
  261.                             if(this.logQuery){
  262.                                 this.logTimer.debug(this.msgDiag.getMessaggio_replaceKeywords("eliminazioneMessaggio"));
  263.                             }
  264.     
  265.                         }catch(Exception e){
  266.                             if(rollbackMessaggio!=null){
  267.                                 ((StateMessage)openspcoopstate.getStatoRichiesta()).closePreparedStatement();
  268.                                 rollbackMessaggio = null;
  269.                             }
  270.                             this.msgDiag.logErroreGenerico(e,"EliminazioneBustaOutbox("+idMsgDaEliminare+")");
  271.                             this.logTimer.error("EliminazioneBustaOutbox("+idMsgDaEliminare+"): "+e.getMessage(),e);
  272.                         }
  273.                     }
  274.                     if(this.logQuery)
  275.                         this.logTimer.info("Eliminate "+busteInutiliOUTBOX.size()+" buste non piu' riferita da messaggi (OUTBOX)");
  276.     
  277.                     boolean cerca = true;
  278.                     try{
  279.                         GestoreMessaggi.updateLock(
  280.                                 this.semaphore, connectionDB, this.timerLock,
  281.                                 this.msgDiag, "Ricerca nuove buste non più riferite da messaggi ...");                      
  282.                     }catch(Throwable e){
  283.                         this.msgDiag.logErroreGenerico(e,"RicercaNuoveBusteOneWayNonRiscontrate-UpdateLock");
  284.                         this.logTimer.error("ErroreRicercaNuoveBusteOneWayNonRiscontrate-UpdateLock: "+e.getMessage(),e);
  285.                         cerca = false;
  286.                     }
  287.                     
  288.                     // Check altri riscontri da inviare
  289.                     if(cerca) {
  290.                         // Check altri messaggi da eliminare
  291.                         busteInutiliINBOX = gestoreMsgSearch.readBusteNonRiferiteDaMessaggiFromInBox(this.limit,this.logQuery,
  292.                                 this.propertiesReader.isForceIndex(),this.orderByQuery);
  293.                         busteInutiliOUTBOX = gestoreMsgSearch.readBusteNonRiferiteDaMessaggiFromOutBox(this.limit,this.logQuery,
  294.                                 this.propertiesReader.isForceIndex(),this.orderByQuery);
  295.                     }
  296.                     else {
  297.                         busteInutiliINBOX = new ArrayList<>(); // per uscire dal while
  298.                         busteInutiliOUTBOX = new ArrayList<>(); // per uscire dal while
  299.                     }
  300.     
  301.                 }
  302.             }finally{
  303.                 try{
  304.                     GestoreMessaggi.releaseLock(
  305.                             this.semaphore, connectionDB, this.timerLock,
  306.                             this.msgDiag, causaMessaggiDaRipulire);
  307.                 }catch(Exception e){
  308.                     // ignore
  309.                 }
  310.             }
  311.                 

  313.             // end
  314.             long endControlloRepositoryMessaggi = DateManager.getTimeMillis();
  315.             long diff = (endControlloRepositoryMessaggi-startControlloRepositoryMessaggi);
  316.             this.logTimer.info("Pulizia Messaggi Anomali terminata in "+Utilities.convertSystemTimeIntoStringMillisecondi(diff, true));

  318.         } 
  319.         catch(TimerLockNotAvailableException t) {
  320.             // msg diagnostico emesso durante l'emissione dell'eccezione
  321.             this.logTimer.info(t.getMessage(),t);
  322.         }
  323.         catch (Exception e) {
  324.             this.msgDiag.logErroreGenerico(e,"GestioneMessaggiInconsistenti");
  325.             this.logTimer.error("Riscontrato errore durante la pulizia dei messaggi anomali: "+e.getMessage(),e);
  326.         }finally{
  327.             if(openspcoopstate!=null)
  328.                 openspcoopstate.releaseResource();
  329.         }
  330.     }

  332. }
Created with JaCoCo 0.8.8.202204050719