TimerGestoreRepositoryBusteLib.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.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.RepositoryBuste;
  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 TimerGestoreRepositoryBuste} 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 TimerGestoreRepositoryBusteLib {

  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 TimerGestoreRepositoryBusteLib(MsgDiagnostico msgDiag,Logger log,OpenSPCoop2Properties p,boolean logQuery,int limit,boolean orderByQuery) throws TimerException{
  82.         this.msgDiag = msgDiag;
  83.         this.logTimer = log;
  84.         this.propertiesReader = p;
  85.         this.logQuery = logQuery;
  86.         this.limit = limit;
  87.         this.orderByQuery = orderByQuery;

  89.         // deve essere utilizzato lo stesso lock per GestoreMessaggi, ConsegnaContenuti, GestoreBuste per risolvere problema di eliminazione descritto in GestoreMessaggi metodo deleteMessageWithLock 
  90.         if(this.propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  91.             this.timerLock = new TimerLock(TipoLock._getLockGestioneRepositoryMessaggi());
  92.         }
  93.         else {
  94.             this.timerLock = new TimerLock(TipoLock.GESTIONE_PULIZIA_REPOSITORY_BUSTE);
  95.         }

  97.         if(this.propertiesReader.isTimerLockByDatabase()) {
  98.             this.semaphore_statistics = new InfoStatistics();

  100.             SemaphoreConfiguration config = GestoreMessaggi.newSemaphoreConfiguration(this.propertiesReader.getTimerGestoreRepositoryBusteLockMaxLife(), 
  101.                     this.propertiesReader.getTimerGestoreRepositoryBusteLockIdleTime());

  103.             TipiDatabase databaseType = TipiDatabase.toEnumConstant(this.propertiesReader.getDatabaseType());
  104.             try {
  105.                 this.semaphore = new Semaphore(this.semaphore_statistics, SemaphoreMapping.newInstance(this.timerLock.getIdLock()), 
  106.                         config, databaseType, this.logTimer);
  107.             }catch(Exception e) {
  108.                 throw new TimerException(e.getMessage(),e);
  109.             }
  110.         }
  111.     }

  113.     public void check() throws TimerException {

  115.         // Controllo che il sistema non sia andando in shutdown
  116.         if(OpenSPCoop2Startup.contextDestroyed){
  117.             this.logTimer.error("["+TimerGestoreRepositoryBuste.ID_MODULO+"] Rilevato sistema in shutdown");
  118.             return;
  119.         }

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

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

  147.         this.msgDiag.logPersonalizzato("controlloInCorso");
  148.         this.logTimer.info(this.msgDiag.getMessaggio_replaceKeywords("controlloInCorso"));
  149.         long startControlloRepositoryBuste = DateManager.getTimeMillis();

  151.         OpenSPCoopStateful openspcoopstate = new OpenSPCoopStateful();
  152.         try {

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

  157.             // Messaggi da eliminare 
  158.             RepositoryBuste repositoryBuste = new RepositoryBuste(openspcoopstate.getStatoRichiesta(),this.logTimer,null);
  159.             boolean trovatiMessaggi = true;

  161.             while(trovatiMessaggi){

  163.                 trovatiMessaggi = false;

  165.                 
  166.                 Date now = null;
  167.                 if(!this.propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  168.                     now = DateManager.getDate(); // vedi spiegazione nel metodo deleteMessageByOraRegistrazione di GestoreMessaggi
  169.                 }
  170.                 
  171.                 
  172.                 // Eliminazione Messaggi from INBOX
  173.                 String causaMessaggiINBOX = "Eliminazione buste (INBOX) marcate logicamente da eliminare";
  174.                 List<String> idMsgINBOX = null;
  175.                 try{
  176.                     GestoreMessaggi.acquireLock(
  177.                             this.semaphore, connectionDB, this.timerLock,
  178.                             this.msgDiag, causaMessaggiINBOX, 
  179.                             this.propertiesReader.getTimerGestoreRepositoryBuste_getLockAttesaAttiva(), 
  180.                             this.propertiesReader.getTimerGestoreRepositoryBuste_getLockCheckInterval());

  182.                     idMsgINBOX = repositoryBuste.getBusteDaEliminareFromInBox(this.limit,this.logQuery,
  183.                             this.propertiesReader.isForceIndex(),this.propertiesReader.isRepositoryBusteFiltraBusteScaduteRispettoOraRegistrazione(),
  184.                             this.orderByQuery, now);
  185.                     int gestiti = 0;
  186.                     if(idMsgINBOX!=null && idMsgINBOX.size()>0){
  187.                         if(this.logQuery)
  188.                             this.logTimer.info("Trovate "+idMsgINBOX.size()+" buste da eliminare nel repository (INBOX) ...");
  189.                         trovatiMessaggi = true;

  191.                         this.msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO,Costanti.INBOX);
  192.                         for(int i=0; i<idMsgINBOX.size(); i++){

  194.                             String idMsgDaEliminare = idMsgINBOX.get(i);
  195.                             this.msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_DA_ELIMINARE,idMsgDaEliminare);

  197.                             try{
  198.                                 try{
  199.                                     GestoreMessaggi.updateLock(
  200.                                             this.semaphore, connectionDB, this.timerLock,
  201.                                             this.msgDiag, "Eliminazione busta INBOX con id ["+idMsgDaEliminare+"] ...");
  202.                                 }catch(Throwable e){
  203.                                     this.msgDiag.logErroreGenerico(e,"EliminazioneBustaInbox("+idMsgDaEliminare+")-UpdateLock");
  204.                                     this.logTimer.error("ErroreEliminazioneBustaInbox("+idMsgDaEliminare+")-UpdateLock: "+e.getMessage(),e);
  205.                                     break;
  206.                                 }

  208.                                 repositoryBuste.eliminaBustaFromInBox(idMsgDaEliminare,now);

  210.                                 this.msgDiag.logPersonalizzato("eliminazioneMessaggio");
  211.                                 if(this.logQuery)
  212.                                     this.logTimer.debug(this.msgDiag.getMessaggio_replaceKeywords("eliminazioneMessaggio"));

  214.                                 gestiti++;

  216.                             }catch(Exception e){
  217.                                 this.msgDiag.logErroreGenerico(e,"EliminazioneBustaInbox("+idMsgDaEliminare+")");
  218.                                 this.logTimer.error("ErroreEliminazioneBustaInbox("+idMsgDaEliminare+"): "+e.getMessage(),e);
  219.                             }
  220.                         }

  222.                         if(this.logQuery)
  223.                             this.logTimer.info("Eliminate "+gestiti+" buste nel repository (INBOX)");
  224.                     }
  225.                     else{
  226.                         if(this.logQuery)
  227.                             this.logTimer.info("Non sono state trovate buste da eliminare nel repository (INBOX)");
  228.                     }
  229.                 }finally{
  230.                     try{
  231.                         GestoreMessaggi.releaseLock(
  232.                                 this.semaphore, connectionDB, this.timerLock,
  233.                                 this.msgDiag, causaMessaggiINBOX);
  234.                     }catch(Exception e){
  235.                         // ignore
  236.                     }
  237.                 }

  239.                 //  Eliminazione Messaggi from OUTBOX
  240.                 String causaMessaggiOUTBOX = "Eliminazione buste (OUTBOX) marcate logicamente da eliminare";
  241.                 List<String> idMsgOUTBOX = null;
  242.                 try{
  243.                     GestoreMessaggi.acquireLock(
  244.                             this.semaphore, connectionDB, this.timerLock,
  245.                             this.msgDiag, causaMessaggiOUTBOX, 
  246.                             this.propertiesReader.getTimerGestoreRepositoryBuste_getLockAttesaAttiva(), 
  247.                             this.propertiesReader.getTimerGestoreRepositoryBuste_getLockCheckInterval());

  249.                     idMsgOUTBOX = repositoryBuste.getBusteDaEliminareFromOutBox(this.limit,this.logQuery,
  250.                             this.propertiesReader.isForceIndex(),this.propertiesReader.isRepositoryBusteFiltraBusteScaduteRispettoOraRegistrazione(),
  251.                             this.orderByQuery,now);
  252.                     int gestiti = 0;
  253.                     if(idMsgOUTBOX!=null && idMsgOUTBOX.size()>0){
  254.                         if(this.logQuery)
  255.                             this.logTimer.info("Trovate "+idMsgOUTBOX.size()+" buste da eliminare nel repository (OUTBOX) ...");
  256.                         trovatiMessaggi = true;

  258.                         this.msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO,Costanti.OUTBOX);
  259.                         for(int i=0; i<idMsgOUTBOX.size(); i++){

  261.                             String idMsgDaEliminare = idMsgOUTBOX.get(i);
  262.                             this.msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_DA_ELIMINARE,idMsgDaEliminare);

  264.                             try{
  265.                                 try{
  266.                                     GestoreMessaggi.updateLock(
  267.                                             this.semaphore, connectionDB, this.timerLock,
  268.                                             this.msgDiag, "Eliminazione busta OUTBOX con id ["+idMsgDaEliminare+"] ...");
  269.                                 }catch(Throwable e){
  270.                                     this.msgDiag.logErroreGenerico(e,"EliminazioneBustaOutbox("+idMsgDaEliminare+")-UpdateLock");
  271.                                     this.logTimer.error("ErroreEliminazioneBustaOutbox("+idMsgDaEliminare+")-UpdateLock: "+e.getMessage(),e);
  272.                                     break;
  273.                                 }

  275.                                 repositoryBuste.eliminaBustaFromOutBox(idMsgDaEliminare,now);

  277.                                 this.msgDiag.logPersonalizzato("eliminazioneMessaggio");
  278.                                 if(this.logQuery)
  279.                                     this.logTimer.debug(this.msgDiag.getMessaggio_replaceKeywords("eliminazioneMessaggio"));

  281.                                 gestiti++;

  283.                             }catch(Exception e){
  284.                                 this.msgDiag.logErroreGenerico(e,"EliminazioneBustaOutbox("+idMsgDaEliminare+")");
  285.                                 this.logTimer.error("ErroreEliminazioneBustaOutbox("+idMsgDaEliminare+"): "+e.getMessage(),e);
  286.                             }
  287.                         }

  289.                         if(this.logQuery)
  290.                             this.logTimer.info("Eliminate "+gestiti+" buste nel repository (OUTBOX)");
  291.                     }
  292.                     else{
  293.                         if(this.logQuery)
  294.                             this.logTimer.info("Non sono state trovate buste da eliminare nel repository (OUTBOX)");
  295.                     }
  296.                 }finally{
  297.                     try{
  298.                         GestoreMessaggi.releaseLock(
  299.                                 this.semaphore, connectionDB, this.timerLock,
  300.                                 this.msgDiag, causaMessaggiOUTBOX);
  301.                     }catch(Exception e){
  302.                         // ignore
  303.                     }
  304.                 }


  307.                 if(trovatiMessaggi){
  308.                     this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_REPOSITORY_BUSTE_NUM_MSG_INBOX, idMsgINBOX!=null ? idMsgINBOX.size()+"" : 0+"");
  309.                     this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_REPOSITORY_BUSTE_NUM_MSG_OUTBOX, idMsgOUTBOX!=null ? idMsgOUTBOX.size()+"" : 0+"");
  310.                     this.msgDiag.logPersonalizzato("ricercaMessaggiDaEliminare");
  311.                 }

  313.             }


  316.             long endControlloRepositoryBuste = DateManager.getTimeMillis();
  317.             long diff = (endControlloRepositoryBuste-startControlloRepositoryBuste);
  318.             this.logTimer.info("Controllo Repository Buste terminato in "+Utilities.convertSystemTimeIntoStringMillisecondi(diff, true));

  320.         } 
  321.         catch(TimerLockNotAvailableException t) {
  322.             // msg diagnostico emesso durante l'emissione dell'eccezione
  323.             this.logTimer.info(t.getMessage(),t);
  324.         }
  325.         catch (Exception e) {
  326.             this.msgDiag.logErroreGenerico(e,"GestioneBuste");
  327.             this.logTimer.error("Riscontrato errore durante l'eliminazione delle buste: "+e.getMessage(),e);
  328.         }finally{
  329.             if(openspcoopstate!=null)
  330.                 openspcoopstate.releaseResource();
  331.         }
  332.     }

  334. }
Created with JaCoCo 0.8.8.202204050719