TimerConsegnaContenutiApplicativi.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.Date;
  28. import java.util.List;
  29. import java.util.Map;

  31. import org.openspcoop2.pdd.config.ConfigurazioneCoda;
  32. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  33. import org.openspcoop2.pdd.config.ConfigurazionePriorita;
  34. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  35. import org.openspcoop2.pdd.core.CostantiPdD;
  36. import org.openspcoop2.pdd.core.GestoreMessaggi;
  37. import org.openspcoop2.pdd.core.MessaggioServizioApplicativo;
  38. import org.openspcoop2.pdd.core.state.OpenSPCoopStateDBManager;
  39. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  40. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  41. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  42. import org.openspcoop2.protocol.engine.constants.Costanti;
  43. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  44. import org.openspcoop2.protocol.sdk.state.StateMessage;
  45. import org.openspcoop2.utils.TipiDatabase;
  46. import org.openspcoop2.utils.Utilities;
  47. import org.openspcoop2.utils.UtilsException;
  48. import org.openspcoop2.utils.date.DateManager;
  49. import org.openspcoop2.utils.id.serial.InfoStatistics;
  50. import org.openspcoop2.utils.semaphore.Semaphore;
  51. import org.openspcoop2.utils.semaphore.SemaphoreConfiguration;
  52. import org.openspcoop2.utils.semaphore.SemaphoreMapping;
  53. import org.openspcoop2.utils.threads.IGestoreCodaRunnableInstance;
  54. import org.openspcoop2.utils.threads.Runnable;
  55. import org.openspcoop2.utils.threads.RunnableLogger;



  59. /**
  60.  * Timer che si occupa di re-inoltrare i messaggi in riconsegna
  61.  * 
  62.  *  
  63.  * @author Poli Andrea (apoli@link.it)
  64.  * @author $Author$
  65.  * @version $Rev$, $Date$
  66.  */

  68. public class TimerConsegnaContenutiApplicativi implements IGestoreCodaRunnableInstance  {

  70.     private static TimerState STATE = TimerState.OFF; // abilitato in OpenSPCoop2Startup al momento dell'avvio

  72.     public static TimerState getSTATE() {
  73.         return STATE;
  74.     }
  75.     public static void setSTATE(TimerState sTATE) {
  76.         STATE = sTATE;
  77.     }

  79.     private MsgDiagnostico msgDiag = null;
  80.     private RunnableLogger log;
  81.     private RunnableLogger logSql;
  82.     private OpenSPCoop2Properties propertiesReader = null;
  83.     private boolean debug;
  84.     private String clusterId;

  86.     private RegistroServiziManager registroServiziReader;
  87.     private ConfigurazionePdDManager configurazionePdDReader;

  89.     private ConfigurazioneCoda configurazioneCoda;
  90.     
  91.     private List<ConfigurazionePriorita> configurazioniPriorita;
  92.     
  93.     private TimerLock timerLock = null;

  95.     /** Semaforo */
  96.     private Semaphore semaphore = null;
  97.     private InfoStatistics semaphore_statistics;

  99.     private Date lastCheckMessaggiDaRispedire = null;
  100.     
  101.     public TimerConsegnaContenutiApplicativi(ConfigurazioneCoda configurazioneCoda, MsgDiagnostico msgDiag,
  102.             RunnableLogger log, RunnableLogger logSql,
  103.             OpenSPCoop2Properties p,
  104.             ConfigurazionePdDManager configurazionePdDReader,RegistroServiziManager registroServiziReader) throws TimerException{
  105.         this.configurazioneCoda = configurazioneCoda;
  106.         this.msgDiag = msgDiag;
  107.         this.log = log;
  108.         this.logSql = logSql;
  109.         this.propertiesReader = p;
  110.         this.debug = configurazioneCoda.isDebug();
  111.         this.clusterId = p.getClusterId(false);
  112.         
  113.         this.configurazioniPriorita = new ArrayList<ConfigurazionePriorita>();
  114.         List<String> prioritaList = this.propertiesReader.getTimerConsegnaContenutiApplicativiPriorita();
  115.         for (int i = 0; i < prioritaList.size(); i++) {
  116.             String priorita = prioritaList.get(i);
  117.             this.configurazioniPriorita.add(this.propertiesReader.getTimerConsegnaContenutiApplicativiConfigurazionePriorita(priorita));
  118.         }
  119.         
  120.         this.configurazionePdDReader = configurazionePdDReader;
  121.         this.registroServiziReader = registroServiziReader;

  123.         // deve essere utilizzato lo stesso lock per GestoreMessaggi, ConsegnaContenuti, GestoreBuste per risolvere problema di eliminazione descritto in GestoreMessaggi metodo deleteMessageWithLock 
  124.         //this.timerLock = new TimerLock(TipoLock.GESTIONE_REPOSITORY_MESSAGGI);
  125.         // l'utilizzo commentato sopra era ERRATO: i messaggi salvati con il timer di consegna contenuti applicativi vengono salvati con un nuovo identificativo 'gw-0-e20ae327-791c-40ef-84ad-4b141a0ef93f' e quindi non impattano sul problema descritto sopra.
  126.         this.timerLock = new TimerLock(TipoLock.CONSEGNA_NOTIFICHE, configurazioneCoda.getName());
  127.         
  128.         if(this.propertiesReader.isTimerLockByDatabase()) {
  129.             this.semaphore_statistics = new InfoStatistics();

  131.             SemaphoreConfiguration config = GestoreMessaggi.newSemaphoreConfiguration(this.propertiesReader.getTimerConsegnaContenutiApplicativiLockMaxLife(), 
  132.                     this.propertiesReader.getTimerConsegnaContenutiApplicativiLockIdleTime());

  134.             TipiDatabase databaseType = TipiDatabase.toEnumConstant(this.propertiesReader.getDatabaseType());
  135.             try {
  136.                 this.semaphore = new Semaphore(this.semaphore_statistics, SemaphoreMapping.newInstance(this.timerLock.getIdLock()), 
  137.                         config, databaseType, this.log.getLog());
  138.             }catch(Exception e) {
  139.                 throw new TimerException(e.getMessage(),e);
  140.             }
  141.         }
  142.     }

  144.     @Override
  145.     public void initialize(RunnableLogger log) throws UtilsException{
  146.         
  147.         OpenSPCoopStateful openspcoopstateGestore = new OpenSPCoopStateful();
  148.         try {

  150.             this.logDebug("Rilascio eventuali messaggi con lock appesi da riconsegnare verso il modulo ConsegnaContenutiApplicativi ...");
  151.             
  152.             openspcoopstateGestore.initResource(this.propertiesReader.getIdentitaPortaDefaultWithoutProtocol(),TimerConsegnaContenutiApplicativiThread.ID_MODULO, "initialize",
  153.                     OpenSPCoopStateDBManager.smistatoreMessaggiPresiInCarico);
  154.             Connection connectionDB = ((StateMessage)openspcoopstateGestore.getStatoRichiesta()).getConnectionDB();

  156.             // GestoreMessaggi da Ricercare
  157.             GestoreMessaggi gestoreMsgSearch = new GestoreMessaggi(openspcoopstateGestore, true,this.logSql.getLog(),this.msgDiag, null);
  158.     
  159.             String causaMessaggiINBOXDaRiconsegnare = "Rilascio eventuali messaggi con lock appesi da riconsegnare verso il modulo ConsegnaContenutiApplicativi";
  160.             try{
  161.                 GestoreMessaggi.acquireLock(
  162.                         this.semaphore, connectionDB, this.timerLock,
  163.                         this.msgDiag, causaMessaggiINBOXDaRiconsegnare, 
  164.                         this.propertiesReader.getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva(), 
  165.                         this.propertiesReader.getTimerConsegnaContenutiApplicativi_getLockCheckInterval());
  166.             
  167.                 gestoreMsgSearch.releaseMessaggiPresaInCosegna(this.configurazioneCoda.getName(), this.clusterId, this.debug, this.logSql);
  168.                 
  169.             }finally{
  170.                 try{
  171.                     GestoreMessaggi.releaseLock(
  172.                             this.semaphore, connectionDB, this.timerLock,
  173.                             this.msgDiag, causaMessaggiINBOXDaRiconsegnare);
  174.                 }catch(Exception e){
  175.                     // ignore
  176.                 }
  177.             }
  178.             
  179.             this.logDebug("Rilascio effettuato di eventuali messaggi con lock appesi da riconsegnare verso il modulo ConsegnaContenutiApplicativi");
  180.         }
  181.         catch (Exception e) {
  182.             this.msgDiag.logErroreGenerico(e,"GestioneMessaggiRilascioLockRiconsegnaConsegnaContenutiApplicativi");
  183.             this.logError("Riscontrato errore durante la gestione del repository dei messaggi (Rilascio lock per riconsegna verso ConsegnaContenutiApplicativi): "+ e.getMessage(),e);
  184.         }finally{
  185.             if(openspcoopstateGestore!=null)
  186.                 openspcoopstateGestore.releaseResource();
  187.         }
  188.     }
  189.     
  190.     private static final String DATA_START = "DATA_START";
  191.     
  192.     @Override
  193.     public void logCheckInProgress(Map<String, Object> context) {
  194.         // Prendo la gestione
  195.         this.msgDiag.logPersonalizzato("controlloInCorso");
  196.         this.log.info(this.msgDiag.getMessaggio_replaceKeywords("controlloInCorso"));
  197.         long startControlloRepositoryMessaggi = DateManager.getTimeMillis();
  198.         context.put(DATA_START, startControlloRepositoryMessaggi);
  199.     }
  200.     
  201.     @Override
  202.     public void logRegisteredThreads(Map<String, Object> context, int nuoviThreadsAttivati) {
  203.         if(nuoviThreadsAttivati>0){
  204.             this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_CONSEGNA_CONTENUTI_APPLICATIVI_NUMERO_MESSAGGI_INOLTRATI,nuoviThreadsAttivati+"");
  205.             this.msgDiag.logPersonalizzato("ricercaMessaggiDaInoltrare");
  206.         }
  207.     }
  208.     
  209.     @Override
  210.     public void logCheckFinished(Map<String, Object> context) {
  211.         
  212.         // end
  213.         long endControlloRepositoryMessaggi = DateManager.getTimeMillis();
  214.         long startControlloRepositoryMessaggi = (Long) context.get(DATA_START);
  215.         long diff = (endControlloRepositoryMessaggi-startControlloRepositoryMessaggi);
  216.         this.log.info("Controllo Repository Messaggi (Riconsegna verso ConsegnaContenutiApplicativi) terminato in "+Utilities.convertSystemTimeIntoStringMillisecondi(diff, true));

  218.     }
  219.     
  220.     
  221.     @Override
  222.     public List<Runnable> nextRunnable(int limit) throws UtilsException{
  223.             
  224.         List<Runnable> returnNull = null;
  225.         
  226.         // Controllo che il sistema non sia andando in shutdown
  227.         if(OpenSPCoop2Startup.contextDestroyed){
  228.             this.logError("Rilevato sistema in shutdown");
  229.             return returnNull;
  230.         }

  232.         // Controllo che l'inizializzazione corretta delle risorse sia effettuata
  233.         if(!OpenSPCoop2Startup.initialize){
  234.             this.msgDiag.logFatalError("inizializzazione di OpenSPCoop non effettuata", "Check Inizializzazione");
  235.             String msgErrore = "Riscontrato errore: inizializzazione del Timer o di OpenSPCoop non effettuata";
  236.             this.logError(msgErrore);
  237.             throw new UtilsException(msgErrore);
  238.         }

  240.         // Controllo risorse di sistema disponibili
  241.         if( !TimerMonitoraggioRisorseThread.isRisorseDisponibili()){
  242.             this.logError("Risorse di sistema non disponibili: "+TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile().getMessage(),TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile());
  243.             return returnNull;
  244.         }
  245.         if( !MsgDiagnostico.gestoreDiagnosticaDisponibile){
  246.             this.logError("Sistema di diagnostica non disponibile: "+MsgDiagnostico.motivoMalfunzionamentoDiagnostici.getMessage(),MsgDiagnostico.motivoMalfunzionamentoDiagnostici);
  247.             return returnNull;
  248.         }
  249.         
  250.         // Controllo che il timer non sia stato momentaneamente disabilitato
  251.         if(!TimerState.ENABLED.equals(STATE)) {
  252.             this.msgDiag.logPersonalizzato("disabilitato");
  253.             this.log.info(this.msgDiag.getMessaggio_replaceKeywords("disabilitato"));
  254.             return returnNull;
  255.         }
  256.         
  257.         OpenSPCoopStateful openspcoopstateGestore = new OpenSPCoopStateful();
  258.         try {

  260.             this.logDebug("Inizializzazione connessione al db per ricercare nuovi threads da attivare (limit: "+limit+") ...");
  261.             openspcoopstateGestore.initResource(this.propertiesReader.getIdentitaPortaDefaultWithoutProtocol(),TimerConsegnaContenutiApplicativiThread.ID_MODULO, "nextRunnable",
  262.                     OpenSPCoopStateDBManager.smistatoreMessaggiPresiInCarico);
  263.             Connection connectionDB = ((StateMessage)openspcoopstateGestore.getStatoRichiesta()).getConnectionDB();

  265.             boolean verificaPresenzaMessaggiDaRispedire = false;
  266.             boolean calcolaDataMinimaMessaggiRispedire = false;
  267.             Integer secondiAnzianitaPerIniziareSpedireNuovoMessaggio = this.configurazioneCoda.getScheduleMessageAfter();
  268.             if(this.lastCheckMessaggiDaRispedire==null) {
  269.                 this.lastCheckMessaggiDaRispedire=DateManager.getDate();
  270.                 verificaPresenzaMessaggiDaRispedire = true;
  271.             }
  272.             else {
  273.                 Date expired = new Date(DateManager.getTimeMillis()-(1000*this.configurazioneCoda.getNextMessages_consegnaFallita_intervalloControllo()));
  274.                 this.logDebug("("+this.configurazioneCoda.getName()+") Verifica check messaggi da spedire previsto quando ultimo chek '"+
  275.                         org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(this.lastCheckMessaggiDaRispedire)+"' < '"+org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(expired)+"' ...");
  276.                 if(this.lastCheckMessaggiDaRispedire.before(expired)) {
  277.                     verificaPresenzaMessaggiDaRispedire = true;
  278.                     this.lastCheckMessaggiDaRispedire=DateManager.getDate();
  279.                 }
  280.             }
  281.             if(verificaPresenzaMessaggiDaRispedire) {
  282.                 calcolaDataMinimaMessaggiRispedire = this.configurazioneCoda.isNextMessages_consegnaFallita_calcolaDataMinimaRiconsegna();
  283.             }
  284.             this.logDebug("("+this.configurazioneCoda.getName()+") verificaPresenzaMessaggiDaRispedire:"+verificaPresenzaMessaggiDaRispedire+" calcolaDataMinimaMessaggiRispedire:"+calcolaDataMinimaMessaggiRispedire);

  286.             
  287.             // GestoreMessaggi da Ricercare
  288.             GestoreMessaggi gestoreMsgSearch = new GestoreMessaggi(openspcoopstateGestore, true,this.logSql.getLog(),this.msgDiag, null);
  289.             
  290.             Date now = DateManager.getDate();
  291.             List<MessaggioServizioApplicativo> msgDaRiconsegnareINBOX = new ArrayList<>();
  292.             
  293.             // APPLICATIVI PRIORITARI
  294.             List<String> serviziApplicativiPrioritari = this.configurazionePdDReader.getServiziApplicativiConsegnaNotifichePrioritarie(this.configurazioneCoda.getName());
  295.             if(serviziApplicativiPrioritari!=null && !serviziApplicativiPrioritari.isEmpty()) {
  296.                 
  297.                 String prefix = "[Applicativi Prioritari] ";
  298.                 String causale = prefix+"Messaggi da riconsegnare verso il modulo ConsegnaContenutiApplicativi";
  299.                 try {
  300.                     this.logDebug(prefix+"Acquisizione lock per ricercare nuovi threads da attivare (limit: "+limit+") ...");
  301.                     this.lock(connectionDB, causale);
  302.                     
  303.                     this.logDebug(prefix+"Lock acquisito, ricerca nuovi threads da attivare (limit: "+limit+") ...");
  304.                     List<MessaggioServizioApplicativo> msgDaRiconsegnareINBOX_priorita = 
  305.                             gestoreMsgSearch.readMessaggiDaRiconsegnareIntoBoxByServiziApplicativPrioritari(limit,
  306.                                     verificaPresenzaMessaggiDaRispedire, calcolaDataMinimaMessaggiRispedire,secondiAnzianitaPerIniziareSpedireNuovoMessaggio,
  307.                                     now,
  308.                                     this.propertiesReader.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife(),
  309.                                     this.debug,this.logSql,
  310.                                     this.configurazioneCoda.getName(),
  311.                                     serviziApplicativiPrioritari.toArray(new String[1]));
  312.                     
  313.                     if(msgDaRiconsegnareINBOX_priorita!=null && !msgDaRiconsegnareINBOX_priorita.isEmpty()) {
  314.                         this.logDebug(prefix+"Ricerca nuovi threads da attivare terminata (limit: "+limit+"); prendo in carico "+
  315.                                 msgDaRiconsegnareINBOX_priorita.size()+" messaggi ...");
  316.                         
  317.                         for (MessaggioServizioApplicativo messaggioServizioApplicativo : msgDaRiconsegnareINBOX_priorita) {
  318.                             GestoreMessaggi messaggioDaInviare = new GestoreMessaggi(openspcoopstateGestore,true,messaggioServizioApplicativo.getIdMessaggio(),Costanti.INBOX,
  319.                                     this.log.getLog(),this.msgDiag,null);
  320.                             messaggioDaInviare.updateMessaggioPresaInCosegna(messaggioServizioApplicativo.getServizioApplicativo(), 
  321.                                     this.clusterId, this.debug, this.logSql);
  322.                             
  323.                             msgDaRiconsegnareINBOX.add(messaggioServizioApplicativo);
  324.                         }
  325.                         
  326.                         this.logDebug(prefix+"Presa in carico "+msgDaRiconsegnareINBOX_priorita.size()+" messaggi terminata, rilascio lock...");
  327.                     }
  328.                     else {
  329.                         this.logDebug(prefix+"Ricerca nuovi threads da attivare terminata (limit: "+limit+"); non sono presenti messaggi, rilascio lock...");
  330.                     }
  331.                     
  332.                 }finally{
  333.                     this.releaseLock(connectionDB, causale);
  334.                 }
  335.                 this.logDebug(prefix+"Lock rilasciato");
  336.             }
  337.             
  338.             int finestraAncoraDisponibileDopoApplicativiPrioritari = limit - msgDaRiconsegnareINBOX.size();
  339.                         
  340.             if(finestraAncoraDisponibileDopoApplicativiPrioritari>0) {
  341.                 for (ConfigurazionePriorita configurazionePriorita : this.configurazioniPriorita) {
  342.     
  343.                     String prefix = "[P-"+configurazionePriorita.getLabel()+"] ";
  344.                     
  345.                     int limitPriorita = 0;
  346.                     if(configurazionePriorita.isNessunaPriorita()) {
  347.                         limitPriorita = limit - msgDaRiconsegnareINBOX.size();
  348.                         this.logDebug(prefix+"Calcolo limit; cerco entries rimaste senza guardare la priorità ("+limitPriorita+") ...");
  349.                     }
  350.                     else {
  351.                         limitPriorita = (finestraAncoraDisponibileDopoApplicativiPrioritari * configurazionePriorita.getPercentuale()) / 100;
  352.                         this.logDebug(prefix+"Calcolo limit; "+configurazionePriorita.getPercentuale()+"% di "+finestraAncoraDisponibileDopoApplicativiPrioritari+": "+limitPriorita+" ...");
  353.                     }
  354.                     if(limitPriorita<=0) {
  355.                         this.logDebug(prefix+"Per la priorità non è necessario cercare alcun messaggio");
  356.                         continue;
  357.                     }
  358.                     
  359.                     String causale = prefix+"Messaggi da riconsegnare verso il modulo ConsegnaContenutiApplicativi";
  360.                     try {
  361.                         this.logDebug(prefix+"Acquisizione lock per ricercare nuovi threads da attivare (limit: "+limitPriorita+") ...");
  362.                         this.lock(connectionDB, causale);
  363.                         
  364.                         this.logDebug(prefix+"Lock acquisito, ricerca nuovi threads da attivare (limit: "+limitPriorita+") ...");
  365.                         List<MessaggioServizioApplicativo> msgDaRiconsegnareINBOXpriorita = 
  366.                                 gestoreMsgSearch.readMessaggiDaRiconsegnareIntoBoxByPriorita(limitPriorita,
  367.                                         verificaPresenzaMessaggiDaRispedire, calcolaDataMinimaMessaggiRispedire, secondiAnzianitaPerIniziareSpedireNuovoMessaggio,
  368.                                         now,
  369.                                         this.propertiesReader.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife(),
  370.                                         this.debug,this.logSql,
  371.                                         this.configurazioneCoda.getName(),
  372.                                         configurazionePriorita.isNessunaPriorita() ? null : configurazionePriorita.getName());
  373.                         
  374.                         if(msgDaRiconsegnareINBOXpriorita!=null && !msgDaRiconsegnareINBOXpriorita.isEmpty()) {
  375.                             this.logDebug(prefix+"Ricerca nuovi threads da attivare terminata (limit: "+limitPriorita+"); prendo in carico "+
  376.                                     msgDaRiconsegnareINBOXpriorita.size()+" messaggi ...");
  377.                             
  378.                             // La finestra non deve essere ricalcolata
  379.                             /**finestraAncoraDisponibileDopoApplicativiPrioritari = finestraAncoraDisponibileDopoApplicativiPrioritari - msgDaRiconsegnareINBOX_priorita.size();*/
  380.                             
  381.                             for (MessaggioServizioApplicativo messaggioServizioApplicativo : msgDaRiconsegnareINBOXpriorita) {
  382.                                 GestoreMessaggi messaggioDaInviare = new GestoreMessaggi(openspcoopstateGestore,true,messaggioServizioApplicativo.getIdMessaggio(),Costanti.INBOX,
  383.                                         this.log.getLog(),this.msgDiag,null);
  384.                                 messaggioDaInviare.updateMessaggioPresaInCosegna(messaggioServizioApplicativo.getServizioApplicativo(), 
  385.                                         this.clusterId, this.debug, this.logSql);
  386.                                 
  387.                                 msgDaRiconsegnareINBOX.add(messaggioServizioApplicativo);
  388.                             }
  389.                             
  390.                             this.logDebug(prefix+"Presa in carico "+msgDaRiconsegnareINBOXpriorita.size()+" messaggi terminata, rilascio lock...");
  391.                         }
  392.                         else {
  393.                             this.logDebug(prefix+"Ricerca nuovi threads da attivare terminata (limit: "+limitPriorita+"); non sono presenti messaggi, rilascio lock...");
  394.                         }
  395.                         
  396.                     }finally{
  397.                         this.releaseLock(connectionDB, causale);
  398.                     }
  399.                     this.logDebug(prefix+"Lock rilasciato");
  400.                     
  401.                 }
  402.             }
  403.             
  404.             this.logDebug("Creazione Runnable ...");
  405.             List<Runnable> listRunnable = null;
  406.             if(msgDaRiconsegnareINBOX!=null && !msgDaRiconsegnareINBOX.isEmpty()) {
  407.                 listRunnable = new ArrayList<>();
  408.                 for (MessaggioServizioApplicativo messaggioServizioApplicativo : msgDaRiconsegnareINBOX) {
  409.                     TimerConsegnaContenutiApplicativiSender sender = 
  410.                             new TimerConsegnaContenutiApplicativiSender(messaggioServizioApplicativo, 
  411.                                     this.registroServiziReader, this.configurazionePdDReader, 
  412.                                     this.clusterId, this.configurazioneCoda);
  413.                     listRunnable.add(new Runnable(sender, -1));
  414.                 }
  415.             }
  416.             this.logDebug("Creazione Runnable terminata");
  417.             
  418.             return listRunnable;
  419.         } 
  420.         catch(TimerLockNotAvailableException t) {
  421.             // msg diagnostico emesso durante l'emissione dell'eccezione
  422.             this.log.info(t.getMessage(),t);
  423.         }
  424.         catch (Exception e) {
  425.             this.msgDiag.logErroreGenerico(e,"GestioneMessaggiRiconsegnaConsegnaContenutiApplicativi");
  426.             this.logError("Riscontrato errore durante la gestione del repository dei messaggi (Riconsegna verso ConsegnaContenutiApplicativi): "+ e.getMessage(),e);
  427.         }finally{
  428.             if(openspcoopstateGestore!=null)
  429.                 openspcoopstateGestore.releaseResource();
  430.         }
  431.         
  432.         return returnNull;
  433.     }

  435.     private void lock(Connection connectionDB, String causale) throws UtilsException, TimerLockNotAvailableException {
  436.         GestoreMessaggi.acquireLock(
  437.                 this.semaphore, connectionDB, this.timerLock,
  438.                 this.msgDiag, causale, 
  439.                 this.propertiesReader.getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva(), 
  440.                 this.propertiesReader.getTimerConsegnaContenutiApplicativi_getLockCheckInterval());
  441.     }
  442.     private void releaseLock(Connection connectionDB, String causale) {
  443.         try{
  444.             GestoreMessaggi.releaseLock(
  445.                     this.semaphore, connectionDB, this.timerLock,
  446.                     this.msgDiag, causale);
  447.         }catch(Exception e){
  448.             // ignore
  449.         }
  450.     }
  451.     
  452.     private void logDebug(String msg) {
  453.         this.logDebug(msg, null);
  454.     }
  455.     private void logDebug(String msg, Throwable e) {
  456.         if(e!=null) {
  457.             this.log.debug(getPrefix()+msg, e);
  458.         }
  459.         else {
  460.             this.log.debug(getPrefix()+msg);
  461.         }
  462.     }
  463.     
  464.     private void logError(String msg) {
  465.         this.logError(msg, null);
  466.     }
  467.     private void logError(String msg, Throwable e) {
  468.         if(e!=null) {
  469.             this.log.error(getPrefix()+msg, e);
  470.         }
  471.         else {
  472.             this.log.error(getPrefix()+msg);
  473.         }
  474.     }
  475.     
  476.     private String getPrefix() {
  477.         if(this.configurazioneCoda!=null) {
  478.             return "["+this.configurazioneCoda.getName()+"] ";
  479.         }
  480.         return "";
  481.     }
  482. }
Created with JaCoCo 0.8.8.202204050719