TimerGestoreBusteNonRiscontrateLib.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.sql.Timestamp;
  27. import java.util.ArrayList;
  28. import java.util.Date;
  29. import java.util.List;

  31. import org.slf4j.Logger;
  32. import org.openspcoop2.core.config.PortaDelegata;
  33. import org.openspcoop2.core.config.ServizioApplicativo;
  34. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  35. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  36. import org.openspcoop2.core.id.IDPortaDelegata;
  37. import org.openspcoop2.core.id.IDServizio;
  38. import org.openspcoop2.core.id.IDServizioApplicativo;
  39. import org.openspcoop2.core.id.IDSoggetto;
  40. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  41. import org.openspcoop2.pdd.config.ClassNameProperties;
  42. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  43. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  44. import org.openspcoop2.pdd.config.RichiestaDelegata;
  45. import org.openspcoop2.pdd.core.AbstractCore;
  46. import org.openspcoop2.pdd.core.CostantiPdD;
  47. import org.openspcoop2.pdd.core.EJBUtilsException;
  48. import org.openspcoop2.pdd.core.GestoreMessaggi;
  49. import org.openspcoop2.pdd.core.PdDContext;
  50. import org.openspcoop2.pdd.core.node.INodeSender;
  51. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  52. import org.openspcoop2.pdd.core.state.OpenSPCoopStateless;
  53. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  54. import org.openspcoop2.pdd.mdb.InoltroBuste;
  55. import org.openspcoop2.pdd.mdb.InoltroBusteMessage;
  56. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  57. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  58. import org.openspcoop2.protocol.engine.constants.Costanti;
  59. import org.openspcoop2.protocol.engine.driver.BustaNonRiscontrata;
  60. import org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione;
  61. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  62. import org.openspcoop2.protocol.engine.driver.Riscontri;
  63. import org.openspcoop2.protocol.engine.driver.RollbackRepositoryBuste;
  64. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  65. import org.openspcoop2.protocol.sdk.Busta;
  66. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  67. import org.openspcoop2.protocol.sdk.Integrazione;
  68. import org.openspcoop2.protocol.sdk.builder.ProprietaErroreApplicativo;
  69. import org.openspcoop2.protocol.sdk.state.StateMessage;
  70. import org.openspcoop2.protocol.sdk.state.StatelessMessage;
  71. import org.openspcoop2.utils.TipiDatabase;
  72. import org.openspcoop2.utils.Utilities;
  73. import org.openspcoop2.utils.date.DateManager;
  74. import org.openspcoop2.utils.id.serial.InfoStatistics;
  75. import org.openspcoop2.utils.resources.Loader;
  76. import org.openspcoop2.utils.semaphore.Semaphore;
  77. import org.openspcoop2.utils.semaphore.SemaphoreConfiguration;
  78. import org.openspcoop2.utils.semaphore.SemaphoreMapping;

  80. /**
  81.  * Implementazione dell'interfaccia {@link TimerGestoreBusteNonRiscontrate} del Gestore
  82.  * dei threads di servizio di OpenSPCoop.
  83.  * 
  84.  *  
  85.  * @author Poli Andrea (apoli@link.it)
  86.  * @author Marcello Spadafora (ma.spadafora@finsiel.it)
  87.  * @author $Author$
  88.  * @version $Rev$, $Date$
  89.  */

  91. public class TimerGestoreBusteNonRiscontrateLib {

  93.     private static TimerState STATE_ONEWAY = TimerState.OFF; // abilitato in OpenSPCoop2Startup al momento dell'avvio
  94.     public static TimerState getSTATE_ONEWAY() {
  95.         return STATE_ONEWAY;
  96.     }
  97.     public static void setSTATE_ONEWAY(TimerState sTATE_ONEWAY) {
  98.         STATE_ONEWAY = sTATE_ONEWAY;
  99.     }

  101.     private static TimerState STATE_ASINCRONI = TimerState.OFF; // abilitato in OpenSPCoop2Startup al momento dell'avvio
  102.     public static TimerState getSTATE_ASINCRONI() {
  103.         return STATE_ASINCRONI;
  104.     }
  105.     public static void setSTATE_ASINCRONI(TimerState sTATE_ASINCRONI) {
  106.         STATE_ASINCRONI = sTATE_ASINCRONI;
  107.     }

  109.     private MsgDiagnostico msgDiag = null;
  110.     private Logger logTimer = null;
  111.     private OpenSPCoop2Properties propertiesReader = null;
  112.     private boolean logQuery = false;
  113.     private int limit = CostantiPdD.LIMIT_MESSAGGI_GESTORI;
  114.     private long timeout = 10;
  115.     private ConfigurazionePdDManager configurazionePdDReader;
  116.     private RegistroServiziManager registroServiziReader;

  118.     /** INodeSender */
  119.     //private static INodeSender nodeSender = null;
  120.     // C'e' lo stato
  121.     private static String tipoNodeSender = null;

  123.     private ProtocolFactoryManager protocolFactoryManager = null;

  125.     private TimerLock timerLock = null;

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

  131.     public TimerGestoreBusteNonRiscontrateLib(MsgDiagnostico msgDiag,Logger log,OpenSPCoop2Properties p,boolean logQuery,int limit,
  132.             long timeout,ConfigurazionePdDManager configurazionePdDReader,RegistroServiziManager registroServiziReader) throws TimerException{
  133.         this.msgDiag = msgDiag;
  134.         this.logTimer = log;
  135.         this.propertiesReader = p;
  136.         this.logQuery = logQuery;
  137.         this.limit = limit;
  138.         this.timeout = timeout;
  139.         this.configurazionePdDReader = configurazionePdDReader;
  140.         this.registroServiziReader = registroServiziReader;
  141.         try{
  142.             this.protocolFactoryManager = ProtocolFactoryManager.getInstance();
  143.         }catch(Exception e){
  144.             // log dell'eventuale errore e' dentro il metodo
  145.             throw new TimerException("Riscontrato errore durante l'inizializzazione del ProtocolFactoryManager: "+e.getMessage(),e);
  146.         }

  148.         if(TimerGestoreBusteNonRiscontrateLib.tipoNodeSender==null){
  149.             try{
  150.                 TimerGestoreBusteNonRiscontrateLib.tipoNodeSender = this.propertiesReader.getNodeSender();
  151.             }catch(Exception e){
  152.                 // log dell'eventuale errore e' dentro il metodo
  153.                 throw new TimerException("Riscontrato errore durante l'inizializzazione del Thread GestoreBusteNonRiscontrate (NodeSender): "+e.getMessage(),e);
  154.             }
  155.         }
  156.         
  157.         this.timerLock = new TimerLock(TipoLock.GESTIONE_BUSTE_NON_RISCONTRATE);

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

  162.             SemaphoreConfiguration config = GestoreMessaggi.newSemaphoreConfiguration(this.propertiesReader.getTimerGestoreRiscontriRicevuteLockMaxLife(), 
  163.                     this.propertiesReader.getTimerGestoreRiscontriRicevuteLockIdleTime());

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


  176.     public void check() throws TimerException {

  178.         // Controllo che il sistema non sia andando in shutdown
  179.         if(OpenSPCoop2Startup.contextDestroyed){
  180.             this.logTimer.error("["+TimerGestoreBusteNonRiscontrate.ID_MODULO+"] Rilevato sistema in shutdown");
  181.             return;
  182.         }
  183.         
  184.         // Controllo che l'inizializzazione corretta delle risorse sia effettuata
  185.         if(!OpenSPCoop2Startup.initialize){
  186.             this.msgDiag.logFatalError("inizializzazione di OpenSPCoop non effettuata", "Check Inizializzazione");
  187.             String msgErrore = "Riscontrato errore: inizializzazione del Timer o di OpenSPCoop non effettuata";
  188.             this.logTimer.error(msgErrore);
  189.             throw new TimerException(msgErrore);
  190.         }

  192.         // Controllo risorse di sistema disponibili
  193.         if( !TimerMonitoraggioRisorseThread.isRisorseDisponibili()){
  194.             this.logTimer.error("["+TimerGestoreBusteNonRiscontrate.ID_MODULO+"] Risorse di sistema non disponibili: "+TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile().getMessage(),TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile());
  195.             return;
  196.         }
  197.         if( !MsgDiagnostico.gestoreDiagnosticaDisponibile){
  198.             this.logTimer.error("["+TimerGestoreBusteNonRiscontrate.ID_MODULO+"] Sistema di diagnostica non disponibile: "+MsgDiagnostico.motivoMalfunzionamentoDiagnostici.getMessage(),MsgDiagnostico.motivoMalfunzionamentoDiagnostici);
  199.             return;
  200.         }

  202.         // Controllo che il timer non sia stato momentaneamente disabilitato
  203.         if(!TimerState.ENABLED.equals(STATE_ONEWAY) && !TimerState.ENABLED.equals(STATE_ASINCRONI)) {
  204.             this.msgDiag.logPersonalizzato("disabilitato");
  205.             this.logTimer.info(this.msgDiag.getMessaggio_replaceKeywords("disabilitato"));
  206.             return;
  207.         }
  208.         
  209.         // refresh
  210.         if( this.configurazionePdDReader.getTimeoutRiscontro() < 1  )   {
  211.             String msgErrore = "Riscontrato errore durante la lettura del timeout per le buste non riscontrate (<=0 ??)";
  212.             this.msgDiag.logErroreGenerico(msgErrore,"getTimeoutRiscontro()");
  213.             this.logTimer.error(msgErrore);
  214.             return;
  215.         }

  217.         this.timeout = this.configurazionePdDReader.getTimeoutRiscontro();
  218.         String minuti = "minuti";
  219.         if(this.timeout == 1)
  220.             minuti = "minuto";
  221.         this.msgDiag.addKeyword(CostantiPdD.KEY_TIMEOUT, this.timeout+" "+minuti);
  222.         this.msgDiag.addKeyword(CostantiPdD.KEY_LIMIT, this.limit+"");
  223.         this.msgDiag.logPersonalizzato("controlloInCorso");
  224.         this.logTimer.info(this.msgDiag.getMessaggio_replaceKeywords("controlloInCorso"));
  225.         long startControlloBusteNonRiscontrate = DateManager.getTimeMillis();


  228.         // Gestione Riscontri...
  229.         GestoreMessaggi gestoreMsg= null;
  230.         GestoreMessaggi messaggioDaInviare= null;
  231.         RepositoryBuste repositoryBuste= null;
  232.         Riscontri gestoreRiscontri = null;
  233.         RollbackRepositoryBuste rollbackRepositoryBuste= null;

  235.         OpenSPCoopStateful openspcoopState = new OpenSPCoopStateful();

  237.         try {

  239.             openspcoopState.initResource(this.propertiesReader.getIdentitaPortaDefaultWithoutProtocol(),TimerGestoreBusteNonRiscontrate.ID_MODULO, null);
  240.             Connection connectionDB = ((StateMessage)openspcoopState.getStatoRichiesta()).getConnectionDB();


  243.             /* ----- Gestione Riscontri per profilo OneWay ----- */
  244.             if(TimerState.ENABLED.equals(STATE_ONEWAY)) {
  245.                 Riscontri rBuste = new Riscontri(openspcoopState.getStatoRichiesta(),this.logTimer);
  246.                 int offsetRiscontri = 0;
  247.                 String causaBusteOneWayToSend = "Rispedizione buste con profilo oneway non riscontrate";
  248.                 List<BustaNonRiscontrata> busteOneWayToSend = null;
  249.                 try{
  250.                     GestoreMessaggi.acquireLock(
  251.                             this.semaphore, connectionDB, this.timerLock,
  252.                             this.msgDiag, causaBusteOneWayToSend, 
  253.                             this.propertiesReader.getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva(), 
  254.                             this.propertiesReader.getTimerGestoreRiscontriRicevuteGetLockCheckInterval());
  255.                     
  256.                     busteOneWayToSend = rBuste.getBustePerUlterioreInoltro(this.timeout,this.limit,offsetRiscontri,this.logQuery);
  257.                     if(this.logQuery &&
  258.                          (busteOneWayToSend != null) && (busteOneWayToSend.isEmpty())){
  259.                         this.logTimer.info("Non sono state trovate buste con profilo oneway non riscontrate da rispedire");
  260.                     }
  261.         
  262.                     // Gestione buste da re-spedire
  263.                     while ( (busteOneWayToSend != null) && (!busteOneWayToSend.isEmpty()) ) {
  264.         
  265.                         if(this.logQuery)
  266.                             this.logTimer.info("Trovate "+busteOneWayToSend.size()+" buste con profilo oneway non riscontrate da rispedire ...");
  267.         
  268.                         int gestiti = 0;
  269.                         for (int i = 0; i < busteOneWayToSend.size(); i++) {
  270.         
  271.                             BustaNonRiscontrata bustaNonRiscontrata = busteOneWayToSend.get(i);
  272.                             String idBustaDaRispedire = bustaNonRiscontrata.getIdentificativo();
  273.                             this.msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, idBustaDaRispedire);
  274.                             this.msgDiag.addKeyword(CostantiPdD.KEY_PROFILO_COLLABORAZIONE, bustaNonRiscontrata.getProfiloCollaborazione().name());
  275.         
  276.                             // Busta da rispedire
  277.                             this.msgDiag.logPersonalizzato("bustaNonRiscontrata");
  278.                             if(this.logQuery){
  279.                                 this.logTimer.debug(this.msgDiag.getMessaggio_replaceKeywords("bustaNonRiscontrata"));
  280.                             }
  281.                             
  282.                             try{
  283.                                 GestoreMessaggi.updateLock(
  284.                                         this.semaphore, connectionDB, this.timerLock,
  285.                                         this.msgDiag, "Rispedizione busta con profilo oneway con id ["+idBustaDaRispedire+"] ...");
  286.                             }catch(Throwable e){
  287.                                 this.msgDiag.logErroreGenerico(e,"RispedizioneBustaNonRiscontrataOneWay("+idBustaDaRispedire+")-UpdateLock");
  288.                                 this.logTimer.error("ErroreRispedizioneBustaNonRiscontrataOneWay("+idBustaDaRispedire+")-UpdateLock: "+e.getMessage(),e);
  289.                                 break;
  290.                             }
  291.         
  292.                             // Controllo che al riscontro corrisponda effettivamente un messaggio nel repository
  293.                             messaggioDaInviare = new GestoreMessaggi(openspcoopState,true,idBustaDaRispedire,Costanti.OUTBOX,
  294.                                     this.logTimer,this.msgDiag,null);
  295.                             if(messaggioDaInviare.existsMessage_noCache()==false){
  296.                                 this.msgDiag.logPersonalizzato("bustaNonRiscontrata.messaggioNonEsistente");
  297.                                 this.logTimer.error(this.msgDiag.getMessaggio_replaceKeywords("bustaNonRiscontrata.messaggioNonEsistente"));
  298.                                 try{
  299.                                     repositoryBuste = new RepositoryBuste(openspcoopState.getStatoRichiesta(), true,null);
  300.                                     repositoryBuste.eliminaUtilizzoPdDFromOutBox(idBustaDaRispedire);
  301.         
  302.                                     gestoreRiscontri = new Riscontri(openspcoopState.getStatoRichiesta(),null);
  303.                                     gestoreRiscontri.validazioneRiscontroRicevuto(idBustaDaRispedire);
  304.         
  305.                                     ((StateMessage)openspcoopState.getStatoRichiesta()).executePreparedStatement();
  306.                                     
  307.                                     gestiti++;
  308.                                     
  309.                                 }catch(Exception e){
  310.                                     this.msgDiag.logErroreGenerico(e,"EliminazioneBustaNonRiscontrataNonEsistente("+idBustaDaRispedire+")");
  311.                                     this.logTimer.error("ErroreEliminazioneBustaNonRiscontrataNonEsistente("+idBustaDaRispedire+"): "+e.getMessage(),e);
  312.                                 }
  313.                             }
  314.                             else{
  315.         
  316.                                 try{
  317.         
  318.                                     // PdDContext
  319.                                     PdDContext pddContext = messaggioDaInviare.getPdDContext(true); // aggiorno anche l'istanza dentro l'oggetto messaggioDaInviare stesso.
  320.                                     IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByName((String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  321.         
  322.                                     // Recupero busta
  323.                                     repositoryBuste = new RepositoryBuste(openspcoopState.getStatoRichiesta(),this.logTimer, true,protocolFactory);
  324.                                     Busta bustaToSend = repositoryBuste.getBustaFromOutBox(idBustaDaRispedire);
  325.                                     this.msgDiag.addKeywords(bustaToSend, true);    
  326.         
  327.                                     // Controllo se la busta e' scaduta
  328.                                     Date scadenza = bustaToSend.getScadenza();
  329.                                     Timestamp now = DateManager.getTimestamp();
  330.         
  331.                                     // Eventuale msg Scaduto.
  332.                                     if (scadenza.before(now)) {
  333.                                         // Busta scaduta
  334.         
  335.                                         this.msgDiag.logPersonalizzato("bustaNonRiscontrataScaduta");
  336.                                         if(this.logQuery)
  337.                                             this.logTimer.info(this.msgDiag.getMessaggio_replaceKeywords("bustaNonRiscontrataScaduta"));
  338.         
  339.                                         try{
  340.                                             repositoryBuste = new RepositoryBuste(openspcoopState.getStatoRichiesta(), true,protocolFactory);
  341.                                             repositoryBuste.eliminaUtilizzoPdDFromOutBox(bustaToSend.getID());
  342.                                             ((StateMessage)openspcoopState.getStatoRichiesta()).executePreparedStatement();
  343.                                             gestoreMsg = new GestoreMessaggi(openspcoopState, true, bustaToSend.getID(),Costanti.OUTBOX,this.msgDiag,pddContext);
  344.                                             gestoreMsg.validateAndDeleteMsgOneWayRiscontrato();
  345.                                         }catch(Exception e){
  346.                                             this.msgDiag.logErroreGenerico(e,"EliminazioneBustaNonRiscontrataScaduta("+bustaToSend.getID()+")");
  347.                                             this.logTimer.error("ErroreEliminazioneBustaNonRiscontrataScaduta("+bustaToSend.getID()+"): "+e.getMessage(),e);
  348.                                         }
  349.         
  350.                                     }
  351.                                     else {
  352.         
  353.                                         // Dati
  354.                                         IDSoggetto soggettoBustaNonRiscontrata = new IDSoggetto(bustaToSend.getTipoMittente(),
  355.                                                 bustaToSend.getMittente());
  356.                                         IDSoggetto identitaPdD = null;
  357.                                         String dominioRD = null;
  358.                                         try{
  359.                                             dominioRD = this.configurazionePdDReader.getIdentificativoPorta(soggettoBustaNonRiscontrata,protocolFactory,null);
  360.                                             if(dominioRD==null){
  361.                                                 throw new Exception("Dominio is null");
  362.                                             }
  363.                                         }catch(Exception e){
  364.                                             this.msgDiag.logErroreGenerico(e,"BustaNonRiscontrata getDominio("+soggettoBustaNonRiscontrata+")");
  365.                                         }
  366.                                         if(dominioRD==null){
  367.                                             identitaPdD = this.propertiesReader.getIdentitaPortaDefaultWithoutProtocol();
  368.                                         }else{
  369.                                             identitaPdD = new IDSoggetto(bustaToSend.getTipoMittente(),
  370.                                                     bustaToSend.getMittente(),dominioRD);
  371.                                         }
  372.                                         IDServizio servizioBusta = IDServizioFactory.getInstance().getIDServizioFromValues(bustaToSend.getTipoServizio(),
  373.                                                 bustaToSend.getServizio(),
  374.                                                 bustaToSend.getTipoDestinatario(), 
  375.                                                 bustaToSend.getDestinatario(), 
  376.                                                 bustaToSend.getVersioneServizio()); 
  377.                                         servizioBusta.setAzione(bustaToSend.getAzione()); 
  378.         
  379.                                         // Dati integrazione
  380.                                         repositoryBuste = new RepositoryBuste(openspcoopState.getStatoRichiesta(), true,protocolFactory);
  381.                                         Integrazione infoIntegrazione = repositoryBuste.getInfoIntegrazioneFromOutBox(bustaToSend.getID());
  382.                                         ProprietaErroreApplicativo erroreAppl = this.propertiesReader.getProprietaGestioneErrorePD(protocolFactory.createProtocolManager());
  383.                                         erroreAppl.setDominio(identitaPdD.getCodicePorta());
  384.         
  385.                                         // RichiestaDelegata
  386.                                         IDPortaDelegata idPD = this.configurazionePdDReader.getIDPortaDelegata(infoIntegrazione.getNomePorta(), null, protocolFactory);
  387.                                         RichiestaDelegata richiestaDelegata = new RichiestaDelegata(
  388.                                                 idPD,infoIntegrazione.getServizioApplicativo(),
  389.                                                 infoIntegrazione.getIdModuloInAttesa(),erroreAppl,identitaPdD);
  390.                                         richiestaDelegata.setScenario(infoIntegrazione.getScenario());
  391.                                         richiestaDelegata.setUtilizzoConsegnaAsincrona(true); // i riscontri sono utilizzati solo con il profilo oneway
  392.                                         richiestaDelegata.setIdCollaborazione(bustaToSend.getCollaborazione());
  393.                                         richiestaDelegata.setProfiloCollaborazione(bustaToSend.getProfiloDiCollaborazione(),bustaToSend.getProfiloDiCollaborazioneValue());
  394.                                         try{
  395.                                             richiestaDelegata.setIdCorrelazioneApplicativa(messaggioDaInviare.getIDCorrelazioneApplicativa());
  396.                                         }catch(Exception e){}
  397.         
  398.                                         // Lettura servizio applicativo
  399.                                         ServizioApplicativo sa = null;
  400.                                         String servizioApplicativo = richiestaDelegata.getServizioApplicativo();
  401.                                         try{
  402.                                             if(servizioApplicativo!=null){
  403.                                                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  404.                                                 idSA.setNome(servizioApplicativo);
  405.                                                 idSA.setIdSoggettoProprietario(richiestaDelegata.getIdSoggettoFruitore());
  406.                                                 sa = this.configurazionePdDReader.getServizioApplicativo(idSA, null);
  407.                                             }
  408.                                         }catch (Exception e) {
  409.                                             if( !(e instanceof DriverConfigurazioneNotFound) || !(CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(servizioApplicativo)) ){
  410.                                                 throw e;
  411.                                             }
  412.                                         }
  413.         
  414.                                         String implementazioneMittente = this.registroServiziReader.getImplementazionePdD(new IDSoggetto(bustaToSend.getTipoMittente(),bustaToSend.getMittente()), null, null);
  415.                                         String implementazioneDestinatario = this.registroServiziReader.getImplementazionePdD(new IDSoggetto(bustaToSend.getTipoDestinatario(),bustaToSend.getDestinatario()), null, null);
  416.         
  417.                                         // Gestione errore del servizio applicativo
  418.                                         this.configurazionePdDReader.aggiornaProprietaGestioneErrorePD(erroreAppl,sa);
  419.         
  420.                                         // Profilo Gestione
  421.                                         String profiloGestione = this.registroServiziReader.getProfiloGestioneFruizioneServizio(servizioBusta, null, null);
  422.                                         richiestaDelegata.setProfiloGestione(profiloGestione);
  423.         
  424.                                         // Identificazione modalita di gestione (oneway 11 o 10)
  425.                                         PortaDelegata pd = this.configurazionePdDReader.getPortaDelegataSafeMethod(idPD, null);
  426.                                         boolean oneWayStateless = this.configurazionePdDReader.isModalitaStateless(pd, bustaToSend.getProfiloDiCollaborazione());
  427.                                         boolean oneWayVersione11 = this.propertiesReader.isGestioneOnewayStateful_1_1() && !oneWayStateless;
  428.         
  429.                                         // costruzione InoltroBuste_MEssage
  430.                                         InoltroBusteMessage inoltroMSG = new InoltroBusteMessage();
  431.                                         inoltroMSG.setRichiestaDelegata(richiestaDelegata);
  432.                                         inoltroMSG.setBusta(bustaToSend);
  433.                                         inoltroMSG.setOneWayVersione11(oneWayVersione11);
  434.                                         if(oneWayVersione11){
  435.                                             OpenSPCoopStateless stateless = new OpenSPCoopStateless();
  436.                                             StatelessMessage statelessMessage = new StatelessMessage();
  437.                                             statelessMessage.setBusta(bustaToSend);
  438.                                             stateless.setStatoRichiesta(statelessMessage);
  439.                                             inoltroMSG.setOpenspcoopstate(stateless);
  440.                                         }
  441.                                         inoltroMSG.setImplementazionePdDSoggettoMittente(implementazioneMittente);
  442.                                         inoltroMSG.setImplementazionePdDSoggettoDestinatario(implementazioneDestinatario);
  443.                                         inoltroMSG.setPddContext(pddContext);
  444.         
  445.                                         gestoreMsg = new GestoreMessaggi(openspcoopState, true, bustaToSend.getID(),Costanti.OUTBOX,this.msgDiag,pddContext);
  446.         
  447.                                         // Send Message on Queue
  448.                                         if(CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_DB.equals(TimerGestoreBusteNonRiscontrateLib.tipoNodeSender)){
  449.                                             gestoreMsg.ripristinaMessaggio();
  450.                                         }else{
  451.                                             try{
  452.         
  453.                                                 String classTypeNodeSender = null;
  454.                                                 INodeSender nodeSender = null;
  455.                                                 try{
  456.                                                     classTypeNodeSender = ClassNameProperties.getInstance().getNodeSender(TimerGestoreBusteNonRiscontrateLib.tipoNodeSender);
  457.                                                     nodeSender = (INodeSender) Loader.getInstance().newInstance(classTypeNodeSender);
  458.                                                     AbstractCore.init(nodeSender, pddContext, protocolFactory);
  459.                                                 }catch(Exception e){
  460.                                                     throw new EJBUtilsException("Riscontrato errore durante il caricamento della classe ["+classTypeNodeSender+
  461.                                                             "] da utilizzare per la spedizione nell'infrastruttura: "+e.getMessage(),e);
  462.                                                 }
  463.         
  464.                                                 nodeSender.send(inoltroMSG, InoltroBuste.ID_MODULO, this.msgDiag, 
  465.                                                         this.propertiesReader.getIdentitaPortaDefaultWithoutProtocol(),TimerGestoreBusteNonRiscontrate.ID_MODULO, bustaToSend.getID(), gestoreMsg);
  466.                                             }catch(Exception e){
  467.                                                 this.msgDiag.logErroreGenerico(e,"GenericLib.nodeSender.send(InoltroBuste)");
  468.                                                 this.logTimer.error("Spedizione->InoltroBuste non riuscita",e);
  469.                                                 return;
  470.                                             }
  471.                                         }
  472.         
  473.                                     }
  474.         
  475.                                     if(this.logQuery)
  476.                                         this.logTimer.debug("Gestita/Reinviata busta OneWay non riscontrata con ID ["+ bustaToSend.getID() + "]");
  477.         
  478.                                     gestiti++;
  479.                                     
  480.                                 }catch(Exception e){
  481.                                     String msgErrore = "RespedizioneBustaNonRiscontrata ErroreGenerale("+idBustaDaRispedire+")";
  482.                                     this.msgDiag.logErroreGenerico(e,msgErrore);
  483.                                     this.logTimer.error(msgErrore+": "+e.getMessage(),e);
  484.                                 }       
  485.         
  486.         
  487.                             }
  488.         
  489.                         }
  490.         
  491.                         if(this.logQuery)
  492.                             this.logTimer.info("Gestite "+gestiti+" buste con profilo oneway non riscontrate da rispedire");
  493.         
  494.                         boolean cerca = true;
  495.                         try{
  496.                             GestoreMessaggi.updateLock(
  497.                                     this.semaphore, connectionDB, this.timerLock,
  498.                                     this.msgDiag, "Ricerca nuovo buste con profilo oneway non riscontrate ...");                        
  499.                         }catch(Throwable e){
  500.                             this.msgDiag.logErroreGenerico(e,"RicercaNuoveBusteOneWayNonRiscontrate-UpdateLock");
  501.                             this.logTimer.error("ErroreRicercaNuoveBusteOneWayNonRiscontrate-UpdateLock: "+e.getMessage(),e);
  502.                             cerca = false;
  503.                         }
  504.                         
  505.                         // Check altri riscontri da inviare
  506.                         if(cerca) {
  507.                             offsetRiscontri = offsetRiscontri + busteOneWayToSend.size(); 
  508.                             busteOneWayToSend = 
  509.                                     rBuste.getBustePerUlterioreInoltro(this.timeout, this.limit, offsetRiscontri, this.logQuery);
  510.                         }
  511.                         else {
  512.                             busteOneWayToSend = new ArrayList<BustaNonRiscontrata>(); // per uscire dal while
  513.                         }
  514.                         
  515.                     }
  516.                 }finally{
  517.                     try{
  518.                         GestoreMessaggi.releaseLock(
  519.                                 this.semaphore, connectionDB, this.timerLock,
  520.                                 this.msgDiag, causaBusteOneWayToSend);
  521.                     }catch(Exception e){}
  522.                 }
  523.             }
  524.             else {
  525.                 if(this.logQuery) {
  526.                     this.logTimer.info("Gestione buste, con profilo oneway, disabilitata");
  527.                 }   
  528.             }





  534.             /* ----- Gestione RicevuteAsincrone per profili Asincroni ----- */
  535.             if(TimerState.ENABLED.equals(STATE_ASINCRONI)) {
  536.                 ProfiloDiCollaborazione pBuste = new ProfiloDiCollaborazione(openspcoopState.getStatoRichiesta(),this.logTimer,null);
  537.                 int offsetBusteAsincrone = 0;
  538.                 String causaBusteAsincroneToSend = "Rispedizione buste con profilo asincrono non riscontrate";
  539.                 try{
  540.                     GestoreMessaggi.acquireLock(
  541.                             this.semaphore, connectionDB, this.timerLock,
  542.                             this.msgDiag, causaBusteAsincroneToSend, 
  543.                             this.propertiesReader.getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva(), 
  544.                             this.propertiesReader.getTimerGestoreRiscontriRicevuteGetLockCheckInterval());
  545.                     
  546.                     List<BustaNonRiscontrata> busteAsincroneToSend = null;
  547.                     busteAsincroneToSend = pBuste.asincrono_getBusteAsincronePerUlterioreInoltro(this.timeout,this.limit,offsetBusteAsincrone,this.logQuery);
  548.                     if(this.logQuery){
  549.                         if( (busteAsincroneToSend != null) && (busteAsincroneToSend.size()<=0)){
  550.                             this.logTimer.info("Non sono state trovate buste con profilo asincrono non riscontrate da rispedire");
  551.                         }
  552.                     }
  553.         
  554.                     // Gestione buste da re-spedire
  555.                     while ( (busteAsincroneToSend != null) && (busteAsincroneToSend.size()>0) ) {
  556.         
  557.                         if(this.logQuery)
  558.                             this.logTimer.info("Trovate "+busteAsincroneToSend.size()+" buste con profilo asincrono non riscontrate da rispedire ...");
  559.         
  560.                         int gestiti = 0;
  561.                         for (int i = 0; i < busteAsincroneToSend.size(); i++) {
  562.         
  563.                             BustaNonRiscontrata bustaNonRiscontrata = busteAsincroneToSend.get(i);
  564.                             String idBustaDaRispedire = bustaNonRiscontrata.getIdentificativo();
  565.                             this.msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, idBustaDaRispedire);
  566.                             this.msgDiag.addKeyword(CostantiPdD.KEY_PROFILO_COLLABORAZIONE, bustaNonRiscontrata.getProfiloCollaborazione().name()); 
  567.         
  568.                             // Busta da rispedire
  569.                             this.msgDiag.logPersonalizzato("ricevutaAsincronaNonRicevuta");
  570.                             if(this.logQuery){
  571.                                 this.logTimer.debug(this.msgDiag.getMessaggio_replaceKeywords("ricevutaAsincronaNonRicevuta"));
  572.                             }
  573.                             
  574.                             try{
  575.                                 GestoreMessaggi.updateLock(
  576.                                         this.semaphore, connectionDB, this.timerLock,
  577.                                         this.msgDiag, "Rispedizione busta con profilo asincrono con id ["+idBustaDaRispedire+"] ...");
  578.                             }catch(Throwable e){
  579.                                 this.msgDiag.logErroreGenerico(e,"RispedizioneBustaNonRiscontrataAsincrona("+idBustaDaRispedire+")-UpdateLock");
  580.                                 this.logTimer.error("ErroreRispedizioneBustaNonRiscontrataAsincrona("+idBustaDaRispedire+")-UpdateLock: "+e.getMessage(),e);
  581.                                 break;
  582.                             }
  583.         
  584.                             // Controllo che alla busta corrisponda effettivamente un messaggio nel repository
  585.                             messaggioDaInviare = new GestoreMessaggi(openspcoopState,true,idBustaDaRispedire,Costanti.OUTBOX,
  586.                                     this.logTimer,this.msgDiag,null);
  587.                             if(messaggioDaInviare.existsMessage_noCache()==false){
  588.                                 this.msgDiag.logPersonalizzato("ricevutaAsincronaNonRicevuta.messaggioNonEsistente");
  589.                                 this.logTimer.error(this.msgDiag.getMessaggio_replaceKeywords("ricevutaAsincronaNonRicevuta.messaggioNonEsistente"));
  590.                                 try{
  591.                                     repositoryBuste = new RepositoryBuste(openspcoopState.getStatoRichiesta(), true,null);
  592.                                     repositoryBuste.eliminaUtilizzoPdDFromOutBox(idBustaDaRispedire);
  593.         
  594.                                     //if(bustaToSend.getRiferimentoMessaggio()==null){
  595.                                     // richiesta
  596.                                     rollbackRepositoryBuste = new RollbackRepositoryBuste(idBustaDaRispedire,openspcoopState.getStatoRichiesta(),true);
  597.                                     rollbackRepositoryBuste.rollbackBustaIntoOutBox();
  598.                                     ((StateMessage)openspcoopState.getStatoRichiesta()).executePreparedStatement();
  599.                                     //}
  600.         
  601.                                     gestiti++;
  602.                                     
  603.                                 }catch(Exception e){
  604.                                     this.msgDiag.logErroreGenerico(e,"EliminazioneBustaAsincronaNonEsistente("+idBustaDaRispedire+")");
  605.                                     this.logTimer.error("ErroreEliminazioneBustaAsincronaNonEsistente("+idBustaDaRispedire+"): "+e.getMessage(),e);
  606.                                 }
  607.                             }else{
  608.         
  609.                                 try{
  610.         
  611.                                     // PdDContext
  612.                                     PdDContext pddContext = messaggioDaInviare.getPdDContext(true); // aggiorno anche l'istanza dentro l'oggetto messaggioDaInviare stesso.;
  613.                                     IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByName((String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  614.         
  615.                                     // Recupero busta
  616.                                     repositoryBuste = new RepositoryBuste(openspcoopState.getStatoRichiesta(),this.logTimer, true,protocolFactory);
  617.                                     Busta bustaToSend = repositoryBuste.getBustaFromOutBox(idBustaDaRispedire);
  618.                                     this.msgDiag.addKeywords(bustaToSend, true);    
  619.         
  620.                                     // Controllo se la busta e' scaduta
  621.                                     Date scadenza = bustaToSend.getScadenza();
  622.                                     Timestamp now = DateManager.getTimestamp();
  623.         
  624.                                     // Eventuale msg Scaduto.
  625.                                     if (scadenza.before(now)) {
  626.                                         // Busta scaduta
  627.         
  628.                                         this.msgDiag.logPersonalizzato("ricevutaAsincronaNonRicevuta.bustaScaduta");
  629.                                         if(this.logQuery){
  630.                                             this.logTimer.info(this.msgDiag.getMessaggio_replaceKeywords("ricevutaAsincronaNonRicevuta.bustaScaduta"));
  631.                                         }
  632.                                         try{
  633.                                             //if(bustaToSend.getRiferimentoMessaggio()==null){
  634.                                             // richiesta
  635.                                             rollbackRepositoryBuste = new RollbackRepositoryBuste(bustaToSend.getID(),openspcoopState.getStatoRichiesta(),true);
  636.                                             rollbackRepositoryBuste.rollbackBustaIntoOutBox();
  637.                                             ((StateMessage)openspcoopState.getStatoRichiesta()).executePreparedStatement();
  638.                                             //}
  639.                                             gestoreMsg = new GestoreMessaggi(openspcoopState, true, bustaToSend.getID(),Costanti.OUTBOX,this.msgDiag,pddContext);
  640.                                             gestoreMsg.logicDeleteMessage();
  641.                                         }catch(Exception e){
  642.                                             this.msgDiag.logErroreGenerico(e,"EliminazioneBustaAsincronaScaduta("+bustaToSend.getID()+")");
  643.                                             this.logTimer.error("ErroreEliminazioneBustaAsincronaScaduta("+bustaToSend.getID()+"): "+e.getMessage(),e);
  644.                                         }
  645.         
  646.                                     }
  647.                                     else {
  648.                                         // Busta da rispedire
  649.         
  650.                                         // Dati
  651.                                         IDSoggetto soggettoBustaNonRiscontrata = new IDSoggetto(bustaToSend.getTipoMittente(),
  652.                                                 bustaToSend.getMittente());
  653.                                         IDSoggetto identitaPdD = null;
  654.                                         String dominioRD = null;
  655.                                         try{
  656.                                             dominioRD = this.configurazionePdDReader.getIdentificativoPorta(soggettoBustaNonRiscontrata,protocolFactory,null);
  657.                                             if(dominioRD==null){
  658.                                                 throw new Exception("Dominio is null");
  659.                                             }
  660.                                         }catch(Exception e){
  661.                                             this.msgDiag.logErroreGenerico(e,"BustaAsincrona getDominio("+soggettoBustaNonRiscontrata+")");
  662.                                             this.logTimer.error("ErroreBustaAsincrona getDominio("+soggettoBustaNonRiscontrata+"): "+e.getMessage(),e);
  663.                                         }
  664.                                         if(dominioRD==null){
  665.                                             identitaPdD = this.propertiesReader.getIdentitaPortaDefaultWithoutProtocol();
  666.                                         }else{
  667.                                             identitaPdD = new IDSoggetto(bustaToSend.getTipoMittente(),
  668.                                                     bustaToSend.getMittente(),dominioRD);
  669.                                         }
  670.                                         IDServizio servizioBusta = IDServizioFactory.getInstance().getIDServizioFromValues(bustaToSend.getTipoServizio(),
  671.                                                 bustaToSend.getServizio(),
  672.                                                 bustaToSend.getTipoDestinatario(), 
  673.                                                 bustaToSend.getDestinatario(), 
  674.                                                 bustaToSend.getVersioneServizio()); 
  675.                                         servizioBusta.setAzione(bustaToSend.getAzione());
  676.         
  677.                                         // Dati integrazione
  678.                                         repositoryBuste = new RepositoryBuste(openspcoopState.getStatoRichiesta(), true,protocolFactory);
  679.                                         Integrazione infoIntegrazione = repositoryBuste.getInfoIntegrazioneFromOutBox(bustaToSend.getID());
  680.                                         ProprietaErroreApplicativo erroreAppl = this.propertiesReader.getProprietaGestioneErrorePD(protocolFactory.createProtocolManager());
  681.                                         erroreAppl.setDominio(identitaPdD.getCodicePorta());
  682.         
  683.                                         // RichiestaDelegata
  684.                                         IDPortaDelegata idPD = this.configurazionePdDReader.getIDPortaDelegata(infoIntegrazione.getNomePorta(), null, protocolFactory);
  685.                                         RichiestaDelegata richiestaDelegata = new RichiestaDelegata(idPD,infoIntegrazione.getServizioApplicativo(),
  686.                                                         infoIntegrazione.getIdModuloInAttesa(),erroreAppl,identitaPdD);
  687.                                         richiestaDelegata.setScenario(infoIntegrazione.getScenario());
  688.                                         if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaToSend.getProfiloDiCollaborazione()) &&
  689.                                                 bustaToSend.getRiferimentoMessaggio() ==null)
  690.                                             richiestaDelegata.setUtilizzoConsegnaAsincrona(false); // una richiesta asincrona simmetrica non deve utilizzare la consegna asincrona della ricevuta applicativa/ok
  691.                                         else
  692.                                             richiestaDelegata.setUtilizzoConsegnaAsincrona(true); 
  693.                                         richiestaDelegata.setRicevutaAsincrona(false); // solo in caso di non-gestione della ricevuta applicativa, viene attivato il timer
  694.         
  695.                                         // Lettura servizio applicativo
  696.                                         ServizioApplicativo sa = null;
  697.                                         String servizioApplicativo = richiestaDelegata.getServizioApplicativo();
  698.                                         try{
  699.                                             if(servizioApplicativo!=null){
  700.                                                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  701.                                                 idSA.setNome(servizioApplicativo);
  702.                                                 idSA.setIdSoggettoProprietario(richiestaDelegata.getIdSoggettoFruitore());
  703.                                                 sa = this.configurazionePdDReader.getServizioApplicativo(idSA, null);
  704.                                             }
  705.                                         }catch (Exception e) {
  706.                                             if( !(e instanceof DriverConfigurazioneNotFound) || !(CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(servizioApplicativo)) ){
  707.                                                 throw e;
  708.                                             }
  709.                                         }
  710.         
  711.                                         // Aggiornamento informazioni integrazioni servizio applicativo
  712.                                         this.configurazionePdDReader.aggiornaProprietaGestioneErrorePD(erroreAppl,sa);
  713.         
  714.                                         // costruzione InoltroBuste_MEssage
  715.                                         InoltroBusteMessage inoltroMSG = new InoltroBusteMessage();
  716.                                         inoltroMSG.setRichiestaDelegata(richiestaDelegata);
  717.                                         inoltroMSG.setBusta(bustaToSend);
  718.         
  719.                                         gestoreMsg = new GestoreMessaggi(openspcoopState, true, bustaToSend.getID(),Costanti.OUTBOX,this.msgDiag,pddContext);
  720.                                         inoltroMSG.setPddContext(pddContext);
  721.         
  722.                                         // Send Message on Queue
  723.                                         if(CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_DB.equals(TimerGestoreBusteNonRiscontrateLib.tipoNodeSender)){
  724.                                             gestoreMsg.ripristinaMessaggio();
  725.                                         }else{
  726.                                             try{
  727.         
  728.                                                 String classTypeNodeSender = null;
  729.                                                 INodeSender nodeSender = null;
  730.                                                 try{
  731.                                                     classTypeNodeSender = ClassNameProperties.getInstance().getNodeSender(TimerGestoreBusteNonRiscontrateLib.tipoNodeSender);
  732.                                                     nodeSender = (INodeSender) Loader.getInstance().newInstance(classTypeNodeSender);
  733.                                                     AbstractCore.init(nodeSender, pddContext, protocolFactory);
  734.                                                 }catch(Exception e){
  735.                                                     throw new EJBUtilsException("Riscontrato errore durante il caricamento della classe ["+classTypeNodeSender+
  736.                                                             "] da utilizzare per la spedizione nell'infrastruttura: "+e.getMessage(),e);
  737.                                                 }
  738.         
  739.                                                 nodeSender.send(inoltroMSG, InoltroBuste.ID_MODULO, this.msgDiag, 
  740.                                                         this.propertiesReader.getIdentitaPortaDefaultWithoutProtocol(),TimerGestoreBusteNonRiscontrate.ID_MODULO, bustaToSend.getID(), gestoreMsg);
  741.                                             }catch(Exception e){
  742.                                                 this.msgDiag.logErroreGenerico(e,"Asincrono GenericLib.nodeSender.send(InoltroBuste)");
  743.                                                 this.logTimer.error("Spedizione->InoltroBuste non riuscita",e);
  744.                                                 return;
  745.                                             }
  746.                                         }
  747.                                     }
  748.         
  749.                                     if(this.logQuery){
  750.                                         this.logTimer.info("Gestita/Reinviata busta asincrona, la cui ricevuta non e' pervenuta, con ID ["+ bustaToSend.getID() + "]");
  751.                                     }
  752.         
  753.                                     gestiti++;
  754.         
  755.                                 }catch(Exception e){
  756.                                     String msgErrore = "RespedizioneBustaAsincrona ErroreGenerale("+idBustaDaRispedire+")";
  757.                                     this.msgDiag.logErroreGenerico(e,msgErrore);
  758.                                     this.logTimer.error(msgErrore+": "+e.getMessage(),e);
  759.                                 }
  760.                             }
  761.         
  762.                         }
  763.         
  764.                         if(this.logQuery)
  765.                             this.logTimer.info("Gestite "+gestiti+" buste con profilo asincrono non riscontrate da rispedire");
  766.         
  767.                         boolean cerca = true;
  768.                         try{
  769.                             GestoreMessaggi.updateLock(
  770.                                     this.semaphore, connectionDB, this.timerLock,
  771.                                     this.msgDiag, "Ricerca nuovo buste con profilo asincrono non riscontrate ...");                     
  772.                         }catch(Throwable e){
  773.                             this.msgDiag.logErroreGenerico(e,"RicercaNuoveBusteAsincroneNonRiscontrate-UpdateLock");
  774.                             this.logTimer.error("ErroreRicercaNuoveBusteAsincroneNonRiscontrate-UpdateLock: "+e.getMessage(),e);
  775.                             cerca = false;
  776.                         }
  777.                         
  778.                         // Check altri riscontri da inviare
  779.                         if(cerca) {                 
  780.                             // Check altre buste da inviare
  781.                             offsetBusteAsincrone = offsetBusteAsincrone + busteAsincroneToSend.size();
  782.                             busteAsincroneToSend = 
  783.                                     pBuste.asincrono_getBusteAsincronePerUlterioreInoltro(this.timeout,this.limit,offsetBusteAsincrone,this.logQuery);
  784.                         }
  785.                         else {
  786.                             busteAsincroneToSend = new ArrayList<BustaNonRiscontrata>(); // per uscire dal while
  787.                         }
  788.                     }
  789.                 }finally{
  790.                     try{
  791.                         GestoreMessaggi.releaseLock(
  792.                                 this.semaphore, connectionDB, this.timerLock,
  793.                                 this.msgDiag, causaBusteAsincroneToSend);
  794.                     }catch(Exception e){}
  795.                 }
  796.             }
  797.             else {
  798.                 if(this.logQuery) {
  799.                     this.logTimer.info("Gestione buste, con profilo asincrono, disabilitata");
  800.                 }   
  801.             }
  802.             

  804.             // end
  805.             long endControlloBusteNonRiscontrate = DateManager.getTimeMillis();
  806.             long diff = (endControlloBusteNonRiscontrate-startControlloBusteNonRiscontrate);
  807.             this.logTimer.info("Controllo Buste in attesa di riscontro terminato in "+Utilities.convertSystemTimeIntoStringMillisecondi(diff, true));

  809.         } 
  810.         catch(TimerLockNotAvailableException t) {
  811.             // msg diagnostico emesso durante l'emissione dell'eccezione
  812.             this.logTimer.info(t.getMessage(),t);
  813.         }
  814.         catch (Exception e) {
  815.             this.msgDiag.logErroreGenerico(e,"GestioneBusteNonRiscontrate");
  816.             this.logTimer.error("Riscontrato errore durante la gestione delle buste non riscontrate: "+ e.getMessage(),e);
  817.             return;
  818.         }finally{
  819.             if(openspcoopState!=null)
  820.                 openspcoopState.releaseResource();
  821.         }
  822.     }

  824. }
Created with JaCoCo 0.8.8.202204050719