TimerConsegnaContenutiApplicativiSender.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.  */

  21. package org.openspcoop2.pdd.timers;

  23. import java.sql.Timestamp;
  24. import java.util.Date;

  26. import org.apache.commons.lang.StringUtils;
  27. import org.openspcoop2.core.config.GestioneErrore;
  28. import org.openspcoop2.core.config.PortaApplicativa;
  29. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  30. import org.openspcoop2.core.config.ServizioApplicativo;
  31. import org.openspcoop2.core.id.IDAccordo;
  32. import org.openspcoop2.core.id.IDPortaApplicativa;
  33. import org.openspcoop2.core.id.IDServizio;
  34. import org.openspcoop2.core.id.IDServizioApplicativo;
  35. import org.openspcoop2.core.id.IDSoggetto;
  36. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  37. import org.openspcoop2.core.registry.PortaDominio;
  38. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  39. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  40. import org.openspcoop2.core.transazioni.IdTransazioneApplicativoServer;
  41. import org.openspcoop2.pdd.config.ConfigurazioneCoda;
  42. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  43. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  44. import org.openspcoop2.pdd.config.RichiestaApplicativa;
  45. import org.openspcoop2.pdd.core.CostantiPdD;
  46. import org.openspcoop2.pdd.core.GestoreMessaggi;
  47. import org.openspcoop2.pdd.core.MessaggioServizioApplicativo;
  48. import org.openspcoop2.pdd.core.PdDContext;
  49. import org.openspcoop2.pdd.core.behaviour.BehaviourForwardToConfiguration;
  50. import org.openspcoop2.pdd.core.behaviour.StatoFunzionalita;
  51. import org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.ConfigurazioneGestioneConsegnaNotifiche;
  52. import org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.GestioneConsegnaNotificheUtils;
  53. import org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.MultiDeliverUtils;
  54. import org.openspcoop2.pdd.core.state.OpenSPCoopStateDBManager;
  55. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  56. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  57. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  58. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  59. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
  60. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativiBehaviourMessage;
  61. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativiMessage;
  62. import org.openspcoop2.pdd.mdb.EsitoLib;
  63. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  64. import org.openspcoop2.protocol.engine.constants.Costanti;
  65. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  66. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  67. import org.openspcoop2.protocol.sdk.Busta;
  68. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  69. import org.openspcoop2.protocol.sdk.state.RequestConfig;
  70. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  71. import org.openspcoop2.utils.UtilsException;
  72. import org.openspcoop2.utils.date.DateManager;
  73. import org.openspcoop2.utils.threads.IRunnableInstance;
  74. import org.openspcoop2.utils.threads.RunnableLogger;

  76. /**
  77.  * Timer che si occupa di re-inoltrare i messaggi in riconsegna
  78.  * 
  79.  *  
  80.  * @author Poli Andrea (apoli@link.it)
  81.  * @author $Author$
  82.  * @version $Rev$, $Date$
  83.  */
  84. public class TimerConsegnaContenutiApplicativiSender implements IRunnableInstance{

  86.     private OpenSPCoop2Properties propertiesReader = null;
  87.     private RegistroServiziManager registroServiziReader;
  88.     private ConfigurazionePdDManager configurazionePdDReader;
  89.     
  90.     private MessaggioServizioApplicativo messaggioServizioApplicativo;
  91.     
  92.     private RunnableLogger log;
  93.     private RunnableLogger logSql;
  94.     private boolean debug;
  95.     
  96.     private String clusterId;
  97.     
  98.     private int minTimeoutResend;
  99.     
  100.     public TimerConsegnaContenutiApplicativiSender(MessaggioServizioApplicativo messaggioServizioApplicativo,
  101.             RegistroServiziManager registroServiziReader,
  102.             ConfigurazionePdDManager configurazionePdDReader,
  103.             String clusterId, ConfigurazioneCoda configurazioneCoda) {
  104.         this.messaggioServizioApplicativo = messaggioServizioApplicativo;
  105.         this.propertiesReader = OpenSPCoop2Properties.getInstance();
  106.         this.registroServiziReader = registroServiziReader;
  107.         this.configurazionePdDReader = configurazionePdDReader;
  108.         this.debug = configurazioneCoda.isDebug();
  109.         this.clusterId = clusterId;
  110.         this.minTimeoutResend = configurazioneCoda.getConsegnaFallita_intervalloMinimoRiconsegna();
  111.     }
  112.     
  113.     @Override
  114.     public String getIdentifier() {
  115.         return "("+this.messaggioServizioApplicativo.getIdTransazione()+"_"+this.messaggioServizioApplicativo.getServizioApplicativo()+"_"+this.messaggioServizioApplicativo.getIdMessaggio()+")";
  116.     }
  117.     
  118.     @Override
  119.     public boolean isContinuousRunning() {
  120.         return false; // deve effettuare solamente una consegna
  121.     }
  122.     
  123.     @Override
  124.     public void initialize(RunnableLogger log) throws UtilsException{
  125.         this.log = log;
  126.         this.logSql = new RunnableLogger(log.getThreadName(),  
  127.                 OpenSPCoop2Logger.getLoggerOpenSPCoopConsegnaContenutiSql(this.debug));
  128.     }
  129.     
  130.     
  131.     @Override
  132.     public void check() throws UtilsException {
  133.         
  134.         String idTransazione = this.messaggioServizioApplicativo.getIdTransazione();
  135.         String servizioApplicativo = this.messaggioServizioApplicativo.getServizioApplicativo();
  136.         String idMsgDaInoltrare = this.messaggioServizioApplicativo.getIdMessaggio();
  137.         String identificativo = "redelivery_"+idTransazione+"_"+servizioApplicativo+"_"+idMsgDaInoltrare;
  138.         Date oraRegistrazione = this.messaggioServizioApplicativo.getOraRegistrazione();
  139.         
  140.         MsgDiagnostico msgDiag = MsgDiagnostico.newInstance(TimerConsegnaContenutiApplicativiThread.ID_MODULO);
  141.         PdDContext pddContext = new PdDContext();
  142.         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, idTransazione);
  143.         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_CONSEGNA_CONTENUTI_APPLICATIVI);
  144.         msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO,Costanti.INBOX);
  145.         msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_DA_INOLTRARE,idMsgDaInoltrare);
  146.         msgDiag.addKeyword(CostantiPdD.KEY_SA_EROGATORE,servizioApplicativo);
  147.         
  148.         OpenSPCoopStateful openspcoopstateGestore = new OpenSPCoopStateful();
  149.         try {

  151.             this.log.debug("Riconsegna in corso del messaggio '"+idMsgDaInoltrare+"' per l'applicativo '"+servizioApplicativo+"' ...");
  152.             
  153.             openspcoopstateGestore.initResource(this.propertiesReader.getIdentitaPortaDefaultWithoutProtocol(),TimerConsegnaContenutiApplicativiThread.ID_MODULO, identificativo,
  154.                     OpenSPCoopStateDBManager.consegnePreseInCarico);
  155.                 
  156.             GestoreMessaggi messaggioDaInviare = null;
  157.             try{
  158.     
  159.                 // FASE 1 PREPARAZIONE
  160.                 
  161.                 RepositoryBuste repositoryBuste = new RepositoryBuste(openspcoopstateGestore.getStatoRichiesta(), true,null);
  162.                 Busta bustaToSend = repositoryBuste.getBustaFromInBox(idMsgDaInoltrare, true);
  163.                 msgDiag.addKeywords(bustaToSend, true);
  164.     
  165.                 IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(bustaToSend.getProtocollo());
  166.     
  167.                 // Per ottimizzare le chiamate
  168.                 RequestInfo requestInfoForMemoryOptimization = new RequestInfo();
  169.                 requestInfoForMemoryOptimization.setProtocolFactory(protocolFactory);
  170.                 msgDiag.updateRequestInfo(requestInfoForMemoryOptimization);
  171.                 
  172.                 messaggioDaInviare = new GestoreMessaggi(openspcoopstateGestore,true,idMsgDaInoltrare,Costanti.INBOX,
  173.                         this.logSql.getLog(),msgDiag,null);
  174.                 pddContext = messaggioDaInviare.getPdDContext(true); // aggiorno anche l'istanza dentro l'oggetto messaggioDaInviare stesso.
  175.     
  176.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO, requestInfoForMemoryOptimization);
  177.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO_IN_MEMORY, true);
  178.                 
  179.                 IDSoggetto soggettoFruitore = null;
  180.                 if(bustaToSend.getMittente()!=null) {
  181.                     soggettoFruitore = new IDSoggetto(bustaToSend.getTipoMittente(),
  182.                             bustaToSend.getMittente());
  183.                 }
  184.     
  185.                 IDServizio servizioBusta = IDServizioFactory.getInstance().getIDServizioFromValues(bustaToSend.getTipoServizio(),
  186.                         bustaToSend.getServizio(),
  187.                         bustaToSend.getTipoDestinatario(), 
  188.                         bustaToSend.getDestinatario(), 
  189.                         bustaToSend.getVersioneServizio()); 
  190.                 if(servizioBusta!=null) {
  191.                     servizioBusta.setAzione(bustaToSend.getAzione());
  192.                 }
  193.                 
  194.                 // Set identità soggetti erogatori usati poi successivamente
  195.                 requestInfoForMemoryOptimization.setRequestConfig(new RequestConfig());
  196.                 if(servizioBusta!=null && servizioBusta.getSoggettoErogatore()!=null) {
  197.                     requestInfoForMemoryOptimization.getRequestConfig().setIdServizio(servizioBusta);
  198.                     try{
  199.                         org.openspcoop2.core.registry.Soggetto soggettoRegistry = this.registroServiziReader.getSoggetto(servizioBusta.getSoggettoErogatore(), null, null); // passo null volutamente, per accedere alla configurazione
  200.                         requestInfoForMemoryOptimization.getRequestConfig().setSoggettoErogatoreRegistry(soggettoRegistry);
  201.                     }catch(Exception e){
  202.                         this.log.getLog().debug("Recupero soggetto erogatore dal registro fallito: "+e.getMessage(),e);
  203.                     }
  204.                     try{
  205.                         org.openspcoop2.core.config.Soggetto soggettoConfig = this.configurazionePdDReader.getSoggetto(servizioBusta.getSoggettoErogatore(), null); // passo null volutamente, per accedere alla configurazione
  206.                         requestInfoForMemoryOptimization.getRequestConfig().setSoggettoErogatoreConfig(soggettoConfig);
  207.                     }catch(Exception e){
  208.                         this.log.getLog().debug("Recupero soggetto erogatore dal registro fallito: "+e.getMessage(),e);
  209.                     }
  210.                     try{
  211.                         String idPorta = this.configurazionePdDReader.getIdentificativoPorta(servizioBusta.getSoggettoErogatore(), protocolFactory, null); // passo null volutamente, per accedere alla configurazione
  212.                         requestInfoForMemoryOptimization.getRequestConfig().setSoggettoErogatoreIdentificativoPorta(idPorta);
  213.                     }catch(Exception e){
  214.                         this.log.getLog().debug("Recupero dati soggetto erogatore (identificativoPorta) dal registro fallito: "+e.getMessage(),e);
  215.                     }
  216.                     try{
  217.                         if(requestInfoForMemoryOptimization.getRequestConfig().getSoggettoErogatoreRegistry()!=null) {
  218.                             if(requestInfoForMemoryOptimization.getRequestConfig().getSoggettoErogatoreRegistry().getPortaDominio()!=null &&
  219.                                     StringUtils.isNotEmpty(requestInfoForMemoryOptimization.getRequestConfig().getSoggettoErogatoreRegistry().getPortaDominio())) {
  220.                                 PortaDominio pdd = this.registroServiziReader.getPortaDominio(requestInfoForMemoryOptimization.getRequestConfig().getSoggettoErogatoreRegistry().getPortaDominio(), null, null); // passo null volutamente, per accedere alla configurazione
  221.                                 requestInfoForMemoryOptimization.getRequestConfig().setSoggettoErogatorePddReaded(true);
  222.                                 requestInfoForMemoryOptimization.getRequestConfig().setSoggettoErogatorePdd(pdd);
  223.                             }
  224.                             else {
  225.                                 requestInfoForMemoryOptimization.getRequestConfig().setSoggettoErogatorePddReaded(true);
  226.                             }
  227.                         }
  228.                     }catch(Exception e){
  229.                         this.log.getLog().debug("Recupero dati soggetto erogatore (pdd) dal registro fallito: "+e.getMessage(),e);
  230.                     }
  231.                 }
  232.     
  233.                 String implementazioneDestinatario = this.registroServiziReader.getImplementazionePdD(new IDSoggetto(bustaToSend.getTipoDestinatario(),bustaToSend.getDestinatario()), null, requestInfoForMemoryOptimization);
  234.                 requestInfoForMemoryOptimization.getRequestConfig().setSoggettoErogatoreImplementazionePdd(implementazioneDestinatario);
  235.                 
  236.                 String implementazioneMittente = null;
  237.                 if(bustaToSend.getTipoMittente()!=null && bustaToSend.getMittente()!=null) {
  238.                     implementazioneMittente = this.registroServiziReader.getImplementazionePdD(new IDSoggetto(bustaToSend.getTipoMittente(),bustaToSend.getMittente()), null, requestInfoForMemoryOptimization);
  239.                     requestInfoForMemoryOptimization.getRequestConfig().setSoggettoFruitoreImplementazionePdd(implementazioneMittente);
  240.                 }
  241.                 
  242.                 IDAccordo idAccordo = null;
  243.                 AccordoServizioParteSpecifica asps = null;
  244.                 try{
  245.                     asps = this.registroServiziReader.getAccordoServizioParteSpecifica(servizioBusta, null, false, requestInfoForMemoryOptimization);
  246.                     idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  247.                     requestInfoForMemoryOptimization.getRequestConfig().setAsps(asps);
  248.                 }catch(Exception e){
  249.                     msgDiag.logErroreGenerico(e,"ConsegnaAsincrona getAccordoServizioParteSpecifica("+servizioBusta+")");
  250.                 }
  251.                     
  252.                 IDSoggetto identitaPdD = null;
  253.                 String dominioRD = null;
  254.                 try{
  255.                     if(servizioBusta!=null) {
  256.                         dominioRD = this.configurazionePdDReader.getIdentificativoPorta(servizioBusta.getSoggettoErogatore(),protocolFactory, requestInfoForMemoryOptimization);
  257.                     }
  258.                     if(dominioRD==null){
  259.                         throw new Exception("Dominio is null");
  260.                     }
  261.                 }catch(Exception e){
  262.                     msgDiag.logErroreGenerico(e,"ConsegnaAsincrona getDominio("+servizioBusta.getSoggettoErogatore()+")");
  263.                 }
  264.                 if(dominioRD==null){
  265.                     identitaPdD = this.propertiesReader.getIdentitaPortaDefault(null, requestInfoForMemoryOptimization);
  266.                 }else{
  267.                     identitaPdD = new IDSoggetto(bustaToSend.getTipoDestinatario(),
  268.                             bustaToSend.getDestinatario(),dominioRD);
  269.                 }
  270.                 requestInfoForMemoryOptimization.setIdentitaPdD(identitaPdD);
  271.                 requestInfoForMemoryOptimization.setIdServizio(servizioBusta);
  272.                 requestInfoForMemoryOptimization.setFruitore(soggettoFruitore);
  273.                     
  274.                 IDPortaApplicativa idPA = this.configurazionePdDReader.getIDPortaApplicativa(this.messaggioServizioApplicativo.getNomePorta(), requestInfoForMemoryOptimization, protocolFactory);
  275.                 requestInfoForMemoryOptimization.getRequestConfig().setIdPortaApplicativa(idPA);
  276.                 RichiestaApplicativa richiestaApplicativa = new RichiestaApplicativa(soggettoFruitore, identitaPdD, idPA);
  277.                 richiestaApplicativa.setServizioApplicativo(servizioApplicativo);
  278.                 richiestaApplicativa.setIdentitaServizioApplicativoFruitore(bustaToSend.getServizioApplicativoFruitore());
  279.                 richiestaApplicativa.setIdAccordo(idAccordo);
  280.     
  281.                 if(servizioBusta!=null) {
  282.                     IDServizioApplicativo idSA = new IDServizioApplicativo();
  283.                     idSA.setNome(richiestaApplicativa.getServizioApplicativo());
  284.                     idSA.setIdSoggettoProprietario(servizioBusta.getSoggettoErogatore());
  285.                     try {
  286.                         ServizioApplicativo sa = this.configurazionePdDReader.getServizioApplicativo(idSA, requestInfoForMemoryOptimization);
  287.                         requestInfoForMemoryOptimization.getRequestConfig().addServizioApplicativoErogatore(sa, idTransazione);
  288.                     }catch(Exception e){
  289.                         this.log.getLog().debug("Recupero dati soggetto erogatore (pdd) dal registro fallito: "+e.getMessage(),e);
  290.                     }
  291.                 }
  292.                 
  293.                 ConsegnaContenutiApplicativiMessage consegnaMSG = new ConsegnaContenutiApplicativiMessage();
  294.                 consegnaMSG.setBusta(bustaToSend);
  295.                 consegnaMSG.setOneWayVersione11(false);
  296.                 consegnaMSG.setStateless(true);
  297.                 consegnaMSG.setImplementazionePdDSoggettoMittente(implementazioneMittente);
  298.                 consegnaMSG.setImplementazionePdDSoggettoDestinatario(implementazioneDestinatario);
  299.                 consegnaMSG.setPddContext(pddContext);
  300.                 consegnaMSG.setRichiestaApplicativa(richiestaApplicativa);
  301.                 
  302.                 BehaviourForwardToConfiguration behaviourForwardToConfiguration = new BehaviourForwardToConfiguration();
  303.                 if(this.messaggioServizioApplicativo.isSbustamentoSoap())
  304.                     behaviourForwardToConfiguration.setSbustamentoSoap(StatoFunzionalita.ABILITATA);
  305.                 else 
  306.                     behaviourForwardToConfiguration.setSbustamentoSoap(StatoFunzionalita.DISABILITATA);
  307.                 if(this.messaggioServizioApplicativo.isSbustamentoInformazioniProtocollo())
  308.                     behaviourForwardToConfiguration.setSbustamentoInformazioniProtocollo(StatoFunzionalita.ABILITATA);
  309.                 else 
  310.                     behaviourForwardToConfiguration.setSbustamentoInformazioniProtocollo(StatoFunzionalita.DISABILITATA);
  311.                 
  312.                 ConsegnaContenutiApplicativiBehaviourMessage behaviourMsg = new ConsegnaContenutiApplicativiBehaviourMessage();
  313.                 behaviourMsg.setIdMessaggioPreBehaviour(bustaToSend.getRiferimentoMessaggio());
  314.                 behaviourMsg.setBehaviourForwardToConfiguration(behaviourForwardToConfiguration);
  315.                 IdTransazioneApplicativoServer idTransazioneApplicativoServer = new IdTransazioneApplicativoServer();
  316.                 idTransazioneApplicativoServer.setIdTransazione(PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext));
  317.                 idTransazioneApplicativoServer.setServizioApplicativoErogatore(servizioApplicativo);
  318.                 PortaApplicativa pa = this.configurazionePdDReader.getPortaApplicativaSafeMethod(idPA, requestInfoForMemoryOptimization);
  319.                 requestInfoForMemoryOptimization.getRequestConfig().setPortaApplicativa(pa);
  320.                 if(pa!=null && pa.getServizioApplicativoList()!=null) {
  321.                     for (PortaApplicativaServizioApplicativo pasa : pa.getServizioApplicativoList()) {
  322.                         if(pasa.getNome().equals(servizioApplicativo)) {
  323.                             if(pasa.getDatiConnettore()!=null) {
  324.                                 idTransazioneApplicativoServer.setConnettoreNome(pasa.getDatiConnettore().getNome());
  325.                             }
  326.                             ConfigurazioneGestioneConsegnaNotifiche configGestioneConsegna = MultiDeliverUtils.read(pasa); 
  327.                             GestioneErrore gestioneErroreBehaviour = GestioneConsegnaNotificheUtils.toGestioneErrore(configGestioneConsegna);       
  328.                             behaviourMsg.setGestioneErrore(gestioneErroreBehaviour);
  329.                             break;
  330.                         }
  331.                     }
  332.                 }
  333.                 behaviourMsg.setIdTransazioneApplicativoServer(idTransazioneApplicativoServer);
  334.                 behaviourMsg.setOraRegistrazioneTransazioneApplicativoServer(oraRegistrazione);
  335.                 consegnaMSG.setBehaviour(behaviourMsg);
  336.                 
  337.                 
  338.                 // FASE 2 SPEDIZIONE
  339.                 
  340.                 // rilasco connessione gestore
  341.                 openspcoopstateGestore.releaseResource();
  342.                 
  343.                 EsitoLib result = null;
  344.                 OpenSPCoopStateful openspcoopstateMessaggio = null;
  345.                 try {
  346.                     ConsegnaContenutiApplicativi lib = new ConsegnaContenutiApplicativi(OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  347.                     openspcoopstateMessaggio = new OpenSPCoopStateful();
  348.                     // viene inizializzata dentro il modulo ConsegnaContenutiApplicativi
  349.                     //openspcoopstateMessaggio.initResource(identitaPdD,TimerConsegnaContenutiApplicativiThread.ID_MODULO, bustaToSend.getID());
  350.                     openspcoopstateMessaggio.setMessageLib(consegnaMSG);
  351.                     result = lib.onMessage(openspcoopstateMessaggio);
  352.                 }finally {
  353.                     try{
  354.                         if(openspcoopstateMessaggio!=null && !openspcoopstateMessaggio.resourceReleased()){
  355.                             openspcoopstateMessaggio.releaseResource();
  356.                         }
  357.                     }catch(Exception e){}
  358.                     
  359.                     // riprendo connessione gestore
  360.                     openspcoopstateGestore.updateResource(identificativo);
  361.                     messaggioDaInviare.updateOpenSPCoopState(openspcoopstateGestore);
  362.                 }
  363.                 
  364.                 
  365.                 
  366.                 if(this.debug)
  367.                     this.log.debug("Invocato ConsegnaContenutiApplicativi per ["+bustaToSend.getID()+
  368.                             "] con esito: "+result.getStatoInvocazione(),result.getErroreNonGestito());
  369.                 if(EsitoLib.ERRORE_NON_GESTITO==result.getStatoInvocazione()){
  370.                     // per evitare i loop infinito
  371.                     Timestamp tMinTimeoutResend = new Timestamp(DateManager.getTimeMillis()+(this.minTimeoutResend*1000));
  372.                     if(result.getDataRispedizioneAggiornata()==null || result.getDataRispedizioneAggiornata().before(tMinTimeoutResend)){
  373.                         messaggioDaInviare.aggiornaDataRispedizione(tMinTimeoutResend, servizioApplicativo);
  374.                     }
  375.                     if(result.isErroreProcessamentoMessaggioAggiornato()==false){
  376.                         if(result.getErroreNonGestito()!=null){
  377.                             messaggioDaInviare.aggiornaErroreProcessamentoMessaggio("["+TimerConsegnaContenutiApplicativiThread.ID_MODULO+"] "+
  378.                                     result.getErroreNonGestito().getMessage(), servizioApplicativo);
  379.                         }
  380.                         else if(result.getMotivazioneErroreNonGestito()!=null){
  381.                             messaggioDaInviare.aggiornaErroreProcessamentoMessaggio("["+TimerConsegnaContenutiApplicativiThread.ID_MODULO+"] "+
  382.                                     result.getMotivazioneErroreNonGestito(), servizioApplicativo);
  383.                         }
  384.                         else{
  385.                             messaggioDaInviare.aggiornaErroreProcessamentoMessaggio("["+TimerConsegnaContenutiApplicativiThread.ID_MODULO+"] "+
  386.                                     "Invocato ConsegnaContenutiApplicativi per ["+bustaToSend.getID()+
  387.                                     "] con esito: "+result.getStatoInvocazione(), servizioApplicativo);
  388.                         }
  389.                     }
  390.                 }
  391.                 else{
  392.     
  393.                     msgDiag.logPersonalizzato("inoltroMessaggio");
  394.                     if(this.debug)
  395.                         this.log.debug(msgDiag.getMessaggio_replaceKeywords("inoltroMessaggio"));
  396.     
  397.                 }
  398.     
  399.             }catch(Exception e){
  400.                 msgDiag.logErroreGenerico(e,"InoltroMessaggioInbox("+idMsgDaInoltrare+")");
  401.                 this.log.error("ErroreInoltroMessaggioInbox("+idMsgDaInoltrare+"): "+e.getMessage(),e);
  402.                 // per evitare i loop infinito
  403.                 if(openspcoopstateGestore!=null && !openspcoopstateGestore.resourceReleased()){
  404.                     messaggioDaInviare.aggiornaDataRispedizione(new Timestamp(DateManager.getTimeMillis()+(this.minTimeoutResend*1000)), servizioApplicativo);
  405.                     messaggioDaInviare.aggiornaErroreProcessamentoMessaggio("["+TimerConsegnaContenutiApplicativiThread.ID_MODULO+"] "+e.getMessage(), servizioApplicativo);
  406.                 }
  407.             }finally{
  408.                 if(openspcoopstateGestore!=null && !openspcoopstateGestore.resourceReleased()){
  409.                     messaggioDaInviare.releaseMessaggioPresaInCosegna(servizioApplicativo, this.clusterId, this.debug, this.logSql); // può già essere stato eliminato
  410.                 }
  411.             }
  412.             
  413.             this.log.debug("Riconsegna in corso del messaggio '"+idMsgDaInoltrare+"' per l'applicativo '"+servizioApplicativo+"' terminata");
  414.         }
  415.         catch (Exception e) {
  416.             msgDiag.logErroreGenerico(e,"GestioneRiconsegnaMessaggio");
  417.             this.log.error("Riscontrato errore durante la consegna del messaggio '"+idMsgDaInoltrare+"' per l'applicativo '"+servizioApplicativo+"': "+ e.getMessage(),e);
  418.         }finally{
  419.             if(openspcoopstateGestore!=null)
  420.                 openspcoopstateGestore.releaseResource();
  421.         }
  422.     }

  424. }
Created with JaCoCo 0.8.8.202204050719