GestoreConsegnaMultipla.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.  */
  20. package org.openspcoop2.pdd.core.transazioni;

  22. import java.security.SecureRandom;
  23. import java.sql.Connection;
  24. import java.util.ArrayList;
  25. import java.util.List;

  27. import org.openspcoop2.core.commons.CoreException;
  28. import org.openspcoop2.core.commons.dao.DAOFactory;
  29. import org.openspcoop2.core.commons.dao.DAOFactoryProperties;
  30. import org.openspcoop2.core.config.OpenspcoopAppender;
  31. import org.openspcoop2.core.config.PortaApplicativa;
  32. import org.openspcoop2.core.config.Property;
  33. import org.openspcoop2.core.config.Tracciamento;
  34. import org.openspcoop2.core.config.utils.OpenSPCoopAppenderUtilities;
  35. import org.openspcoop2.core.id.IDPortaApplicativa;
  36. import org.openspcoop2.core.id.IDSoggetto;
  37. import org.openspcoop2.core.transazioni.TransazioneApplicativoServer;
  38. import org.openspcoop2.core.transazioni.dao.ITransazioneApplicativoServerService;
  39. import org.openspcoop2.core.transazioni.utils.TransactionServerUtils;
  40. import org.openspcoop2.generic_project.utils.ServiceManagerProperties;
  41. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  42. import org.openspcoop2.pdd.config.DBConsegneMessageBoxManager;
  43. import org.openspcoop2.pdd.config.DBConsegnePreseInCaricoManager;
  44. import org.openspcoop2.pdd.config.DBTransazioniManager;
  45. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  46. import org.openspcoop2.pdd.config.Resource;
  47. import org.openspcoop2.pdd.core.handlers.transazioni.ExceptionSerialzerFileSystem;
  48. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  49. import org.openspcoop2.pdd.core.state.OpenSPCoopState;
  50. import org.openspcoop2.pdd.core.state.OpenSPCoopStateDBManager;
  51. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  52. import org.openspcoop2.protocol.sdk.Context;
  53. import org.openspcoop2.protocol.sdk.ProtocolException;
  54. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  55. import org.openspcoop2.protocol.sdk.diagnostica.IDiagnosticProducer;
  56. import org.openspcoop2.protocol.sdk.dump.IDumpProducer;
  57. import org.openspcoop2.protocol.sdk.dump.Messaggio;
  58. import org.openspcoop2.protocol.sdk.state.IState;
  59. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  60. import org.openspcoop2.protocol.sdk.state.StateMessage;
  61. import org.openspcoop2.protocol.utils.EsitiConfigUtils;
  62. import org.openspcoop2.protocol.utils.EsitiProperties;
  63. import org.openspcoop2.utils.Utilities;
  64. import org.openspcoop2.utils.date.DateManager;
  65. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  66. import org.slf4j.Logger;

  68. /**     
  69.  * GestoreConsegnaMultipla
  70.  *
  71.  * @author Poli Andrea (poli@link.it)
  72.  * @author $Author$
  73.  * @version $Rev$, $Date$
  74.  */
  75. public class GestoreConsegnaMultipla {

  77.     private static final String ID_MODULO = "GestoreConsegnaMultipla";

  79.     private static DAOFactory daoFactory = null;
  80.     private static DAOFactory daoFactoryDevNull = null;
  81.     private static ServiceManagerProperties daoFactoryServiceManagerPropertiesTransazioni = null;
  82.     private static ServiceManagerProperties daoFactoryDevNullServiceManagerPropertiesTransazioni = null;
  83.     /**private static Logger daoFactoryLoggerTransazioni = null;*/
  84.     private static Logger daoFactoryLoggerTransazioniSql = null;
  85.     private static Logger daoFactoryLoggerTransazioniDevNull = null;

  87.     private static OpenSPCoop2Properties openspcoopProperties = null;

  89.     private static GestoreConsegnaMultipla gestoreConsegnaMultipla = null;
  90.     private static synchronized void init() throws TransactionMultiDeliverException{
  91.         if(gestoreConsegnaMultipla==null){
  92.             String tipoDatabase = null;
  93.             boolean debug = false;
  94.             Logger daoFactoryLoggerTransazioni = null;
  95.             try{
  96.                 openspcoopProperties = OpenSPCoop2Properties.getInstance();

  98.                 tipoDatabase = openspcoopProperties.getDatabaseType();
  99.                 /**System.out.println("DS["+this.datasource+"] TIPODB["+this.tipoDatabase+"]");*/

  101.                 if(tipoDatabase==null){
  102.                     throw new TransactionMultiDeliverException("Tipo Database non definito");
  103.                 }

  105.                 openspcoopProperties = OpenSPCoop2Properties.getInstance();

  107.                 debug = openspcoopProperties.isTransazioniDebug();

  109.                 daoFactoryLoggerTransazioni = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioni(debug);
  110.                 daoFactoryLoggerTransazioniSql = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniSql(debug);
  111.                 daoFactoryLoggerTransazioniDevNull = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniDevNull();
  112.                 
  113.                 daoFactory = DAOFactory.getInstance(daoFactoryLoggerTransazioniSql);
  114.                 DAOFactoryProperties daoFactoryProperties = DAOFactoryProperties.getInstance(daoFactoryLoggerTransazioniSql);
  115.                 daoFactoryServiceManagerPropertiesTransazioni = daoFactoryProperties.getServiceManagerProperties(org.openspcoop2.core.transazioni.utils.ProjectInfo.getInstance());
  116.                 daoFactoryServiceManagerPropertiesTransazioni.setShowSql(debug);    
  117.                 daoFactoryServiceManagerPropertiesTransazioni.setDatabaseType(DBTransazioniManager.getInstance().getTipoDatabase());
  118.                 
  119.                 daoFactoryDevNull = DAOFactory.getInstance(daoFactoryLoggerTransazioniDevNull);
  120.                 DAOFactoryProperties daoFactoryPropertiesDevNull = DAOFactoryProperties.getInstance(daoFactoryLoggerTransazioniDevNull);
  121.                 daoFactoryDevNullServiceManagerPropertiesTransazioni = daoFactoryPropertiesDevNull.getServiceManagerProperties(org.openspcoop2.core.transazioni.utils.ProjectInfo.getInstance());
  122.                 daoFactoryDevNullServiceManagerPropertiesTransazioni.setShowSql(debug); 
  123.                 daoFactoryDevNullServiceManagerPropertiesTransazioni.setDatabaseType(DBTransazioniManager.getInstance().getTipoDatabase());
  124.                 

  126.             }catch(Exception e){
  127.                 throw new TransactionMultiDeliverException("Inizializzazione risorse database non riuscita: "+e.getMessage(),e);
  128.             }
  129.             try{
  130.                 gestoreConsegnaMultipla = new GestoreConsegnaMultipla(daoFactoryLoggerTransazioni, daoFactoryLoggerTransazioniSql,
  131.                         tipoDatabase,
  132.                         debug);
  133.             }catch(Exception e){
  134.                 throw new TransactionMultiDeliverException("Inizializzazione GestoreConsegnaMultipla non riuscita: "+e.getMessage(),e);
  135.             }
  136.         }
  137.     }
  138.     public static GestoreConsegnaMultipla getInstance() throws TransactionMultiDeliverException {
  139.         if(gestoreConsegnaMultipla==null){
  140.             // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED': l'istanza viene creata allo startup
  141.             synchronized (GestoreConsegnaMultipla.class) {
  142.                 init();
  143.             }
  144.         }
  145.         return gestoreConsegnaMultipla;
  146.     }


  149.     
  150.     
  151.     private static java.util.Random rndInstance = null;
  152.     private static synchronized void initRandom() {
  153.         if(rndInstance==null) {
  154.             rndInstance = new SecureRandom();
  155.         }
  156.     }
  157.     public static java.util.Random getRandom() {
  158.         if(rndInstance==null) {
  159.             initRandom();
  160.         }
  161.         return rndInstance;
  162.     }
  163.     




  168.     private Logger log = null;
  169.     private Logger logSql = null;
  170.     private String tipoDatabase = null;
  171.     private boolean debug = false;

  173.     private IDiagnosticProducer msgDiagnosticiOpenSPCoopAppender = null;
  174.     private IDumpProducer dumpOpenSPCoopAppender = null;
  175.     private boolean transazioniRegistrazioneDumpHeadersCompactEnabled = false;

  177.     private GestoreConsegnaMultipla(Logger log,Logger logSql,
  178.             String tipoDatabase,boolean debug) throws TransactionMultiDeliverException{

  180.         this.log = log;
  181.         this.logSql = logSql;
  182.         this.tipoDatabase = tipoDatabase;
  183.         this.debug = debug;

  185.         boolean usePdDConnection = true;

  187.         try{

  189.             // Init
  190.             this.msgDiagnosticiOpenSPCoopAppender = new org.openspcoop2.pdd.logger.MsgDiagnosticoOpenSPCoopProtocolAppender();
  191.             OpenspcoopAppender diagnosticoOpenSPCoopAppender = new OpenspcoopAppender();
  192.             diagnosticoOpenSPCoopAppender.setTipo("__gestoreConsegnaMultipla");
  193.             List<Property> diagnosticoOpenSPCoopAppenderProperties = new ArrayList<>();

  195.             // Verra poi utilizzata la connessione ottenuta ogni volta che il timer viene eseguito, infatti si usa usePdDConnection
  196.             OpenSPCoopAppenderUtilities.addParameters(this.logSql, diagnosticoOpenSPCoopAppenderProperties, 
  197.                     null, // nessun datasource
  198.                     null, null, null, null,  // nessuna connection
  199.                     this.tipoDatabase,
  200.                     usePdDConnection, // viene usata la connessione della PdD
  201.                     this.debug
  202.                     );
  203.             OpenSPCoopAppenderUtilities.addCheckProperties(diagnosticoOpenSPCoopAppenderProperties, false);

  205.             diagnosticoOpenSPCoopAppender.setPropertyList(diagnosticoOpenSPCoopAppenderProperties);
  206.             this.msgDiagnosticiOpenSPCoopAppender.initializeAppender(diagnosticoOpenSPCoopAppender);
  207.             this.msgDiagnosticiOpenSPCoopAppender.isAlive();

  209.         }catch(Exception e){
  210.             throw new TransactionMultiDeliverException("Errore durante l'inizializzazione del DiagnosticoAppender: "+e.getMessage(),e);
  211.         } 

  213.         try{

  215.             // Init
  216.             this.dumpOpenSPCoopAppender = new org.openspcoop2.pdd.logger.DumpOpenSPCoopProtocolAppender();
  217.             OpenspcoopAppender dumpOpenSPCoopAppenderEngine = new OpenspcoopAppender();
  218.             dumpOpenSPCoopAppenderEngine.setTipo("__gestoreConsegnaMultipla");
  219.             List<Property> dumpOpenSPCoopAppenderProperties = new ArrayList<>();

  221.             // Verra poi utilizzata la connessione ottenuta ogni volta che il timer viene eseguito, infatti si usa usePdDConnection
  222.             OpenSPCoopAppenderUtilities.addParameters(this.logSql, dumpOpenSPCoopAppenderProperties, 
  223.                     null, // nessun datasource
  224.                     null, null, null, null,  // nessuna connection
  225.                     this.tipoDatabase,
  226.                     usePdDConnection, // viene usata la connessione della PdD
  227.                     this.debug
  228.                     );
  229.             OpenSPCoopAppenderUtilities.addCheckProperties(dumpOpenSPCoopAppenderProperties, false);

  231.             dumpOpenSPCoopAppenderEngine.setPropertyList(dumpOpenSPCoopAppenderProperties);
  232.             this.dumpOpenSPCoopAppender.initializeAppender(dumpOpenSPCoopAppenderEngine);
  233.             this.dumpOpenSPCoopAppender.isAlive();
  234.             
  235.             // Indicazioni sulle modalita' di salvataggio degli header del dump
  236.             this.transazioniRegistrazioneDumpHeadersCompactEnabled = openspcoopProperties.isTransazioniRegistrazioneDumpHeadersCompactEnabled();

  238.         }catch(Exception e){
  239.             throw new TransactionMultiDeliverException("Errore durante l'inizializzazione del DumpAppender: "+e.getMessage(),e);
  240.         } 

  242.     }


  245.     // *** SAFE ***

  247.     public void safeCreate(TransazioneApplicativoServer transazioneApplicativoServer, IDPortaApplicativa idPA, IOpenSPCoopState state, RequestInfo requestInfo, Context context) {

  249.         // cluster id
  250.         transazioneApplicativoServer.setClusterIdPresaInCarico(openspcoopProperties.getClusterId(false));
  251.         
  252.         getConnectionAndSave(transazioneApplicativoServer, transazioneApplicativoServer.getProtocollo(), false, false, idPA, state, null, requestInfo, context, "create",
  253.                 OpenSPCoopStateDBManager.runtime);

  255.     }
  256.     
  257.     public void safeUpdateConsegna(TransazioneApplicativoServer transazioneApplicativoServer, IDPortaApplicativa idPA, IOpenSPCoopState state, RequestInfo requestInfo, Context context) {

  259.         // cluster id
  260.         transazioneApplicativoServer.setClusterIdConsegna(openspcoopProperties.getClusterId(false));
  261.         
  262.         getConnectionAndSave(transazioneApplicativoServer, transazioneApplicativoServer.getProtocollo(), true, true, idPA, state, null, requestInfo, context, "updateDeliveredMessage",
  263.                 OpenSPCoopStateDBManager.consegnePreseInCarico); // l'informazione dovrebbe esistere!

  265.     }
  266.     
  267.     public void safeUpdatePrelievoIM(TransazioneApplicativoServer transazioneApplicativoServer, IDPortaApplicativa idPA, IOpenSPCoopState state, Context context) {

  269.         // cluster id
  270.         transazioneApplicativoServer.setClusterIdPrelievoIm(openspcoopProperties.getClusterId(false));
  271.         
  272.         getConnectionAndSave(transazioneApplicativoServer, transazioneApplicativoServer.getProtocollo(), true, false, idPA, state, null, null, context, "updateRetrieveMessageByMessageBox",
  273.                 OpenSPCoopStateDBManager.messageBox);

  275.     }
  276.     
  277.     public void safeUpdateEliminazioneIM(TransazioneApplicativoServer transazioneApplicativoServer, IDPortaApplicativa idPA, IOpenSPCoopState state, Context context) {

  279.         // cluster id
  280.         transazioneApplicativoServer.setClusterIdEliminazioneIm(openspcoopProperties.getClusterId(false));
  281.         
  282.         getConnectionAndSave(transazioneApplicativoServer, transazioneApplicativoServer.getProtocollo(), true, false, idPA, state, null, null, context, "updateDeletedMessageByMessageBox",
  283.                 OpenSPCoopStateDBManager.messageBox);

  285.     }
  286.     
  287.     public void safeUpdateMessaggioScaduto(TransazioneApplicativoServer transazioneApplicativoServer, IDPortaApplicativa idPA, IOpenSPCoopState state) {

  289.         getConnectionAndSave(transazioneApplicativoServer, transazioneApplicativoServer.getProtocollo(), true, false, idPA, state, null, null, null, "updateExpiredMessage",
  290.                 OpenSPCoopStateDBManager.runtime);

  292.     }

  294.     
  295.     public void safeSave(org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico diagnostico, IDPortaApplicativa idPA, IState state, RequestInfo requestInfo, Context context) {

  297.         getConnectionAndSave(diagnostico, diagnostico.getProtocollo(), false, false, idPA, null, state, requestInfo, context, "saveDiagnostic",
  298.                 OpenSPCoopStateDBManager.consegnePreseInCarico);

  300.     }

  302.     public void safeSave(Messaggio dumpMessaggio, IDPortaApplicativa idPA, IState state, RequestInfo requestInfo, Context context) {

  304.         getConnectionAndSave(dumpMessaggio, dumpMessaggio.getProtocollo(), false, false, idPA, null, state, requestInfo, context, "saveContent",
  305.                 OpenSPCoopStateDBManager.consegnePreseInCarico);

  307.     }

  309.     private void getConnectionAndSave(Object o, String protocol, boolean update, boolean throwNotFoundIfNotExists, IDPortaApplicativa idPA, 
  310.             IOpenSPCoopState openspcoopState, IState state, RequestInfo requestInfo, Context context,
  311.             String tipoOperazione,
  312.             OpenSPCoopStateDBManager dbManagerSource) {
  313.         TransazioniSAProcessTimes times = null;
  314.         long timeStart = -1;
  315.         boolean buildDetailsSA = false;
  316.         boolean buildDetailsUpdateTransaction = false;
  317.         if(openspcoopProperties.isTransazioniRegistrazioneSlowLog()) {
  318.             times = new TransazioniSAProcessTimes();
  319.             timeStart = DateManager.getTimeMillis();
  320.             buildDetailsSA = openspcoopProperties.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails();
  321.             buildDetailsUpdateTransaction = openspcoopProperties.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails();
  322.         }
  323.         try {
  324.             getConnectionAndSave(o, protocol, update, throwNotFoundIfNotExists, idPA, 
  325.                     openspcoopState, state, requestInfo, context,
  326.                     tipoOperazione, times, buildDetailsSA,  buildDetailsUpdateTransaction,
  327.                     dbManagerSource);
  328.         }finally {
  329.             if(times!=null) {
  330.                 long timeEnd =  DateManager.getTimeMillis();
  331.                 long timeProcess = timeEnd-timeStart;
  332.                 if(timeProcess>=openspcoopProperties.getTransazioniRegistrazioneSlowLogThresholdMs()) {
  333.                     StringBuilder sb = new StringBuilder();
  334.                     sb.append(timeProcess);
  335.                     if(times.idTransazione!=null) {
  336.                         sb.append(" <").append(times.idTransazione).append(">");
  337.                     }
  338.                     if(times.servizioApplicativoErogatore!=null) {
  339.                         sb.append(" (sa:").append(times.servizioApplicativoErogatore).append(")");
  340.                     }
  341.                     sb.append(" [GestoreConsegnaMultipla."+tipoOperazione+"]");
  342.                     sb.append(" ").append(times.toString());
  343.                     String msg = sb.toString();
  344.                     OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniSlowLog().info(msg);
  345.                 }
  346.             }
  347.         }
  348.     }
  349.     @SuppressWarnings("resource")
  350.     private void getConnectionAndSave(Object o, String protocol, boolean update, boolean throwNotFoundIfNotExists, IDPortaApplicativa idPA, 
  351.             IOpenSPCoopState openspcoopState, IState state, RequestInfo requestInfo, Context context,
  352.             String tipoOperazione, TransazioniSAProcessTimes times, boolean buildDetailsSA, boolean buildDetailsUpdateTransaction,
  353.             OpenSPCoopStateDBManager dbManagerSource) {

  355.         EsitiProperties esitiProperties = null;
  356.         try {
  357.             if(requestInfo!=null && requestInfo.getProtocolFactory()!=null) {
  358.                 esitiProperties = EsitiProperties.getInstance(this.log, requestInfo.getProtocolFactory());
  359.                 if(esitiProperties==null &&
  360.                     // per i casi di restart nodi in cui vengono modificati gli id delle chiavi, mentre serializzato nel messaggio e' rimasto il precedente
  361.                     requestInfo.getProtocolFactory().getProtocol()!=null) {
  362.                     esitiProperties = EsitiProperties.getInstanceFromProtocolName(this.log, requestInfo.getProtocolFactory().getProtocol());
  363.                 }
  364.             }
  365.             else {
  366.                 esitiProperties = EsitiProperties.getInstanceFromProtocolName(this.log, protocol);
  367.             }
  368.         }catch(Throwable e) {
  369.             this.log.error("Errore avvenuto durante la lettura del gestore degli esiti: "+e.getMessage() ,e);
  370.         }
  371.         if(esitiProperties==null) {
  372.             return;
  373.         }
  374.         
  375.         try{
  376.             ConfigurazionePdDManager configPdDManager = ConfigurazionePdDManager.getInstance(); 
  377.             Tracciamento configTracciamento = configPdDManager.getOpenSPCoopAppenderTracciamento();
  378.             StringBuilder bf = new StringBuilder();
  379.             String esitiConfig = configTracciamento!=null ? configTracciamento.getEsiti() : null;
  380.             if(idPA!=null) {
  381.                 PortaApplicativa pa = configPdDManager.getPortaApplicativaSafeMethod(idPA, requestInfo);
  382.                 if(pa!=null && pa.getTracciamento()!=null && pa.getTracciamento().getEsiti()!=null) {
  383.                     esitiConfig = pa.getTracciamento().getEsiti();
  384.                 }
  385.             }
  386.             List<String> esitiDaRegistrare = EsitiConfigUtils.getRegistrazioneEsiti(esitiConfig, this.log, bf);
  387.             
  388.             int code = esitiProperties.convertoToCode(EsitoTransazioneName.CONSEGNA_MULTIPLA);
  389.             String codeAsString = code+"";
  390.             if(esitiDaRegistrare!=null && !esitiDaRegistrare.isEmpty() && !esitiDaRegistrare.contains(codeAsString)){
  391.                 String msg = "Non devo registrare l'informazione, esito '"+codeAsString+"' disabilitato nel tracciamento";
  392.                 this.log.debug(msg);
  393.                 return;
  394.             }
  395.             
  396.         }catch(Throwable e) {
  397.             this.log.debug("Errore avvenuto durante la lettura della configurazione delle transazioni da salvare: "+e.getMessage(),e); 
  398.         }
  399.         
  400.         String richiedenteConnessione = null;
  401.         if(o!=null) {
  402.             if(o instanceof TransazioneApplicativoServer) {
  403.                 richiedenteConnessione = tipoOperazione+ "_" +((TransazioneApplicativoServer)o).getIdTransazione();
  404.                 richiedenteConnessione = richiedenteConnessione + "_" + ((TransazioneApplicativoServer)o).getServizioApplicativoErogatore();
  405.                 if(times!=null) {
  406.                     times.idTransazione = ((TransazioneApplicativoServer)o).getIdTransazione();
  407.                     times.servizioApplicativoErogatore = ((TransazioneApplicativoServer)o).getServizioApplicativoErogatore();
  408.                 }
  409.             }
  410.             else if(o instanceof org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico) {
  411.                 richiedenteConnessione = tipoOperazione+ "_" +((org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico)o).getIdTransazione();
  412.                 if(times!=null) {
  413.                     times.idTransazione = ((org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico)o).getIdTransazione();
  414.                 }
  415.             }
  416.             else if(o instanceof Messaggio) {
  417.                 richiedenteConnessione = tipoOperazione+ "_" +((Messaggio)o).getIdTransazione();
  418.                 if(times!=null) {
  419.                     times.idTransazione = ((Messaggio)o).getIdTransazione();
  420.                 }
  421.             }
  422.         }
  423.         
  424.         Resource dbResource = null;
  425.         DBTransazioniManager dbManagerTransazioni = null;
  426.         DBConsegnePreseInCaricoManager dbConsegnePreseInCaricoManager = null;
  427.         DBConsegneMessageBoxManager dbConsegneMessageBoxManager = null;
  428.         if(dbManagerSource!=null) {
  429.             switch (dbManagerSource) {
  430.             case runtime:
  431.                 dbManagerTransazioni = DBTransazioniManager.getInstance();
  432.                 break;
  433.             case consegnePreseInCarico:
  434.                 dbConsegnePreseInCaricoManager = DBConsegnePreseInCaricoManager.getInstanceTransazioni();
  435.                 break;
  436.             case smistatoreMessaggiPresiInCarico: // non utilizzato
  437.                 dbConsegnePreseInCaricoManager = DBConsegnePreseInCaricoManager.getInstanceTransazioni();
  438.                 break;
  439.             case messageBox:
  440.                 dbConsegneMessageBoxManager = DBConsegneMessageBoxManager.getInstanceTransazioni();
  441.                 break;
  442.             }
  443.         }
  444.         else {
  445.             dbManagerTransazioni = DBTransazioniManager.getInstance();
  446.         }
  447.         IDSoggetto idDominio = openspcoopProperties.getIdentitaPortaDefault(protocol, requestInfo);
  448.         ExceptionSerialzerFileSystem exceptionSerializerFileSystem = new ExceptionSerialzerFileSystem(this.log);
  449.         Connection con = null;
  450.         boolean isMessaggioConsegnato = false;
  451.         boolean possibileTerminazioneSingleIntegrationManagerMessage = false;
  452.         boolean consegnaInErrore = false;
  453.         TransazioneApplicativoServer transazioneApplicativoServer = null;
  454.         boolean useConnectionRuntime = false;
  455.         try{
  456.             long timeStart = -1;
  457.             try{
  458.                 if(times!=null) {
  459.                     timeStart = DateManager.getTimeMillis();
  460.                 }
  461.                 boolean checkPddRuntimeDatasource = false;
  462.                 if(dbManagerTransazioni!=null) {
  463.                     checkPddRuntimeDatasource = dbManagerTransazioni.useRuntimePdD();
  464.                 }
  465.                 else if(dbConsegnePreseInCaricoManager!=null) {
  466.                     checkPddRuntimeDatasource = dbConsegnePreseInCaricoManager.useRuntimePdD();
  467.                 }
  468.                 else if(dbConsegneMessageBoxManager!=null) {
  469.                     checkPddRuntimeDatasource = dbConsegneMessageBoxManager.useRuntimePdD();
  470.                 }
  471.                 
  472.                 if(checkPddRuntimeDatasource) {
  473.                     if(openspcoopState!=null) {
  474.                         if(openspcoopState instanceof OpenSPCoopState) {
  475.                             OpenSPCoopState s = (OpenSPCoopState) openspcoopState;
  476.                             if(s.getConnectionDB()!=null && !s.getConnectionDB().isClosed()) {
  477.                                 con = s.getConnectionDB();
  478.                                 useConnectionRuntime = true;
  479.                             }
  480.                         }
  481.                     }
  482.                     else if(state instanceof StateMessage) {
  483.                         StateMessage s = (StateMessage) state;
  484.                         if(s.getConnectionDB()!=null && !s.getConnectionDB().isClosed()) {
  485.                             con = s.getConnectionDB();
  486.                             useConnectionRuntime = true;
  487.                         }
  488.                     }
  489.                 }
  490.                 
  491.                 if(!useConnectionRuntime){
  492.                     if(dbManagerTransazioni!=null) {
  493.                         dbResource = dbManagerTransazioni.getResource(idDominio, ID_MODULO, richiedenteConnessione);
  494.                     }
  495.                     else if(dbConsegnePreseInCaricoManager!=null) {
  496.                         dbResource = dbConsegnePreseInCaricoManager.getResource(idDominio, ID_MODULO, richiedenteConnessione);
  497.                     }
  498.                     else if(dbConsegneMessageBoxManager!=null){
  499.                         dbResource = dbConsegneMessageBoxManager.getResource(idDominio, ID_MODULO, richiedenteConnessione);
  500.                     }
  501.                     
  502.                     if(dbResource!=null) {
  503.                         con = (Connection) dbResource.getResource();
  504.                     }
  505.                 }
  506.                 
  507.             }finally {  
  508.                 if(times!=null) {
  509.                     long timeEnd =  DateManager.getTimeMillis();
  510.                     long timeProcess = timeEnd-timeStart;
  511.                     times.getConnection = timeProcess;
  512.                 }
  513.             }
  514.                 
  515.             boolean autoCommit = false;
  516.             if(con!=null) {
  517.                 con.setAutoCommit(autoCommit);
  518.             }

  520.             if(o instanceof TransazioneApplicativoServer) {
  521.                 int conflict = 0;
  522.                 int iteration = 1; // inizio da 1 per i log
  523.                 boolean updateEffettuato = false;
  524.                 try{
  525.                     if(times!=null) {
  526.                         timeStart = DateManager.getTimeMillis();
  527.                         if(buildDetailsSA) {
  528.                             times.saDetails = new ArrayList<>();
  529.                         }
  530.                     }
  531.                     
  532.                     org.openspcoop2.core.transazioni.dao.jdbc.JDBCServiceManager jdbcServiceManager =
  533.                             (org.openspcoop2.core.transazioni.dao.jdbc.JDBCServiceManager) daoFactory.getServiceManager(org.openspcoop2.core.transazioni.utils.ProjectInfo.getInstance(), 
  534.                                     con, autoCommit,
  535.                                     daoFactoryServiceManagerPropertiesTransazioni,
  536.                                     daoFactoryLoggerTransazioniDevNull);
  537.                     jdbcServiceManager.getJdbcProperties().setShowSql(this.debug);
  538.                     ITransazioneApplicativoServerService transazioneService = jdbcServiceManager.getTransazioneApplicativoServerService();
  539.     
  540.                     // ** Aggiorno campi dipendenti da questa invocazione **
  541.                     // Campi che non possono essere gestiti a livello 'core'
  542.     
  543.                     transazioneApplicativoServer = (TransazioneApplicativoServer) o;
  544.     
  545.                     // dettaglio esito
  546.                     this.setDettaglioEsito(transazioneApplicativoServer, esitiProperties, context);
  547.                     
  548.                     // consegna terminata
  549.                     if(transazioneApplicativoServer.isConsegnaTerminata()) {
  550.                         isMessaggioConsegnato = true;
  551.                     }
  552.                     else if(transazioneApplicativoServer.getDataEliminazioneIm()!=null
  553.                             ||
  554.                             transazioneApplicativoServer.getDataMessaggioScaduto()!=null) {
  555.                         isMessaggioConsegnato = true;
  556.                         possibileTerminazioneSingleIntegrationManagerMessage = true;
  557.                     }
  558.                     else if(transazioneApplicativoServer.isConsegnaTrasparente() && transazioneApplicativoServer.getDataUscitaRichiesta()!=null) {
  559.                         // !transazioneApplicativoServer.isConsegnaTerminata() altrimenti entrava nel primo if
  560.                         consegnaInErrore = true;
  561.                     }
  562.     
  563.                     boolean useSelectForUpdate = true;
  564.                     /*
  565.                      * Grazie alla select for update riesco a mettere il lock solamente sulla riga interessata
  566.                      */
  567.                     
  568.                     int oldTransactionIsolation = -1;
  569.                     if(!useSelectForUpdate) {
  570.                         try{
  571.                             oldTransactionIsolation = con.getTransactionIsolation();
  572.                             /** già effettuato fuori dal metodo connectionDB.setAutoCommit(false);*/
  573.                             JDBCUtilities.setTransactionIsolationSerializable(daoFactoryServiceManagerPropertiesTransazioni.getDatabase(), con);
  574.                         } catch(Exception er) {
  575.                             throw new CoreException("(setIsolation) "+er.getMessage(),er);
  576.                         }
  577.                     }
  578.                     
  579.                     long gestioneSerializableDBAttesaAttiva = openspcoopProperties.getGestioneSerializableDBAttesaAttiva();
  580.                     int gestioneSerializableDBCheckInterval = openspcoopProperties.getGestioneSerializableDBCheckInterval();
  581.                     
  582.                     long scadenzaWhile = DateManager.getTimeMillis() + gestioneSerializableDBAttesaAttiva;
  583.                     
  584.                     Throwable lastT = null;
  585.                     while(!updateEffettuato && DateManager.getTimeMillis() < scadenzaWhile){
  586.     
  587.                         List<String> timeDetails = null;
  588.                         try{
  589.                             
  590.                             if(times!=null && buildDetailsSA) {
  591.                                 timeDetails = new ArrayList<>();
  592.                             }
  593.                             
  594.                             boolean transazioneAggiornata = TransactionServerUtils.save(transazioneService, (TransazioneApplicativoServer)o, update, throwNotFoundIfNotExists, false, 
  595.                                     useSelectForUpdate, timeDetails);
  596.                                                         
  597.                             long timeStartCommit = -1;
  598.                             if(timeDetails!=null) {
  599.                                 timeStartCommit = DateManager.getTimeMillis();
  600.                             }
  601.                             if(con!=null) {
  602.                                 con.commit();
  603.                             }
  604.                             if(timeDetails!=null) {
  605.                                 long timeEnd =  DateManager.getTimeMillis();
  606.                                 long timeProcess = timeEnd-timeStartCommit;
  607.                                 timeDetails.add("commit:"+timeProcess);
  608.                             }
  609.                             
  610.                             if(!transazioneAggiornata) {
  611.                                 isMessaggioConsegnato = false; // per gestire eventuali errori durante il  recupero da file system
  612.                             }
  613.     
  614.                             updateEffettuato = true;
  615.     
  616.                         } catch(Throwable e) {
  617.                             conflict++;
  618.                             lastT = e;
  619.                             if(timeDetails!=null) {
  620.                                 String errorMsg = e.getMessage();
  621.                                 if(errorMsg!=null) {
  622.                                     if(errorMsg.length()>100) {
  623.                                         errorMsg = errorMsg.substring(0, 97)+"...";
  624.                                     }
  625.                                     timeDetails.add("error:"+errorMsg);
  626.                                 }
  627.                             }
  628.                             /**System.out.println("Serializable error:"+e.getMessage());*/
  629.                             try{
  630.                                 if(con!=null) {
  631.                                     con.rollback();
  632.                                 }
  633.                             } catch(Exception er) {}
  634.                         }finally {
  635.                             if(timeDetails!=null && !timeDetails.isEmpty()) {
  636.                                 for (String detail : timeDetails) {
  637.                                     times.saDetails.add("i"+iteration+"-"+detail);
  638.                                 }
  639.                             }
  640.                         }
  641.     
  642.                         if(!updateEffettuato){
  643.                             // Per aiutare ad evitare conflitti
  644.                             try{
  645.                                 Utilities.sleep(getRandom().nextInt(gestioneSerializableDBCheckInterval)); // random da 0ms a checkIntervalms
  646.                             }catch(Exception eRandom){
  647.                                 // ignore
  648.                             }
  649.                             iteration++;
  650.                         }
  651.                     }
  652.                     // Ripristino Transazione
  653.                     if(!useSelectForUpdate) {
  654.                         try{
  655.                             if(con!=null) {
  656.                                 con.setTransactionIsolation(oldTransactionIsolation);
  657.                             }
  658.                             /** già effettuato fuori dal metodo connectionDB.setAutoCommit(true);*/
  659.                         } catch(Exception er) {
  660.                             throw new CoreException("(ripristinoIsolation) "+er.getMessage(),er);
  661.                         }
  662.                     }
  663.                     if(lastT!=null && !updateEffettuato) {
  664.                         // registro ultimo errore avvenuto durante il ciclo
  665.                         String msgError = "[id:"+transazioneApplicativoServer.getIdTransazione()+"][sa:"+transazioneApplicativoServer.getServizioApplicativoErogatore()+"]["+transazioneApplicativoServer.getConnettoreNome()+"] 'updateTransazioneSA' failed: "+lastT.getMessage();
  666.                         daoFactoryLoggerTransazioniSql.error(msgError,lastT);
  667.                         this.log.error(msgError,lastT);
  668.                         throw lastT;
  669.                     }
  670.                 }finally {  
  671.                     if(times!=null) {
  672.                         long timeEnd =  DateManager.getTimeMillis();
  673.                         long timeProcess = timeEnd-timeStart;
  674.                         if(update) {
  675.                             times.update = timeProcess;
  676.                         }
  677.                         else {
  678.                             times.insert = timeProcess;
  679.                         }
  680.                         if(buildDetailsSA) {
  681.                             times.saDetails.add("iteration:"+iteration);
  682.                             times.saDetails.add("conflicts:"+conflict);
  683.                             times.saDetails.add("updated:"+updateEffettuato);
  684.                         }
  685.                     }
  686.                 }
  687.             }
  688.             else if(o instanceof org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico) {
  689.                 try{
  690.                     if(times!=null) {
  691.                         timeStart = DateManager.getTimeMillis();
  692.                     }
  693.                     
  694.                     this.msgDiagnosticiOpenSPCoopAppender.log(con, (org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico)o);
  695.                     
  696.                     if(con!=null) {
  697.                         con.commit();
  698.                     }
  699.                 }finally {  
  700.                     if(times!=null) {
  701.                         long timeEnd =  DateManager.getTimeMillis();
  702.                         long timeProcess = timeEnd-timeStart;
  703.                         times.insert = timeProcess;
  704.                     }
  705.                 }
  706.             }
  707.             else if(o instanceof Messaggio) {
  708.                 try{
  709.                     if(times!=null) {
  710.                         timeStart = DateManager.getTimeMillis();
  711.                     }
  712.                     
  713.                     this.dumpOpenSPCoopAppender.dump(con, (Messaggio)o, this.transazioniRegistrazioneDumpHeadersCompactEnabled);
  714.                     
  715.                     if(con!=null) {
  716.                         con.commit();
  717.                     }
  718.                 }finally {  
  719.                     if(times!=null) {
  720.                         long timeEnd =  DateManager.getTimeMillis();
  721.                         long timeProcess = timeEnd-timeStart;
  722.                         times.insert = timeProcess;
  723.                     }
  724.                 }
  725.             }

  727.         }catch(Throwable e){
  728.             try{
  729.                 if(con!=null) {
  730.                     con.rollback();
  731.                 }
  732.             }catch(Exception eRollback){
  733.                 // ignore
  734.             }

  736.             if(o instanceof TransazioneApplicativoServer) {
  737.                 
  738.                 isMessaggioConsegnato = false; // per gestire eventuali errori durante il  recupero da file system
  739.                 
  740.                 TransazioneApplicativoServer serverInfo = (TransazioneApplicativoServer) o;
  741.                 try{
  742.                     if(serverInfo.getIdTransazione()!=null && serverInfo.getServizioApplicativoErogatore()!=null) {
  743.                         // NOTA: volutamente salvo serverInfo per poter reimplementare la logica di cui sopra
  744.                         serverInfo.setProtocollo(protocol);
  745.                         exceptionSerializerFileSystem.registrazioneFileSystemTransazioneApplicativoServerEmessoPdD(serverInfo, serverInfo.getIdTransazione(), serverInfo.getServizioApplicativoErogatore());
  746.                     }
  747.                 } catch (Throwable eClose) {
  748.                     // ignore
  749.                 }
  750.                 // Effettuo il log anche nel core per evitare che un eventuale filtro a OFF sul core della PdD eviti la scrittura di questi errori
  751.                 String msg = "Errore durante la scrittura dell'informazione del server '"+serverInfo.getServizioApplicativoErogatore()+"' associato alla transazione sul database: " + e.getLocalizedMessage();
  752.                 this.log.error("["+serverInfo.getIdTransazione()+"] "+msg,e);
  753.             }
  754.             else if(o instanceof org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico) {
  755.                 org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico msgDiag = (org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico) o;
  756.                 try{
  757.                     if(msgDiag.getIdTransazione()!=null && msgDiag.getApplicativo()!=null) {
  758.                         exceptionSerializerFileSystem.registrazioneFileSystemDiagnosticoEmessoPdD(msgDiag, msgDiag.getIdTransazione(), msgDiag.getApplicativo());
  759.                     }
  760.                 } catch (Throwable eClose) {
  761.                     // ignore
  762.                 }
  763.                 // Effettuo il log anche nel core per evitare che un eventuale filtro a OFF sul core della PdD eviti la scrittura di questi errori
  764.                 String msg = "Errore durante la scrittura del diagnostico relativo al server '"+msgDiag.getApplicativo()+"' associato alla transazione sul database: " + e.getLocalizedMessage();
  765.                 this.log.error("["+msgDiag.getIdTransazione()+"] "+msg,e);
  766.             }
  767.             else if(o instanceof Messaggio) {
  768.                 Messaggio messaggio = (Messaggio) o;
  769.                 try{
  770.                     if(messaggio.getIdTransazione()!=null && messaggio.getServizioApplicativoErogatore()!=null) {
  771.                         exceptionSerializerFileSystem.registrazioneFileSystemDumpEmessoPdD(messaggio, messaggio.getIdTransazione(), 
  772.                                 messaggio.getServizioApplicativoErogatore(), messaggio.getDataConsegna());
  773.                     }
  774.                 } catch (Throwable eClose) {
  775.                     // ignore
  776.                 }
  777.                 // Effettuo il log anche nel core per evitare che un eventuale filtro a OFF sul core della PdD eviti la scrittura di questi errori
  778.                 String msg = "Errore durante la scrittura del messaggio relativo al server '"+messaggio.getServizioApplicativoErogatore()+"' associato alla transazione sul database: " + e.getLocalizedMessage();
  779.                 this.log.error("["+messaggio.getIdTransazione()+"] "+msg,e);
  780.             }

  782.         }finally{
  783.             
  784.             if(isMessaggioConsegnato || consegnaInErrore) {

  786.                 long timeStart = -1;
  787.                 try{
  788.                     List<String> timeDetails = null;
  789.                     if(times!=null) {
  790.                         timeStart = DateManager.getTimeMillis();
  791.                         if(buildDetailsUpdateTransaction) {
  792.                             times.transazioneDetails = new ArrayList<>();
  793.                             timeDetails = times.transazioneDetails;
  794.                         }
  795.                     }
  796.                 
  797.                     // aggiorno esito transazione (non viene sollevata alcuna eccezione)
  798.                     boolean transazioneAggiornata = safeAggiornaInformazioneConsegnaTerminata(transazioneApplicativoServer, con, esitiProperties, possibileTerminazioneSingleIntegrationManagerMessage, consegnaInErrore, timeDetails);
  799.                     if(!transazioneAggiornata) {
  800.                         
  801.                         String prefix = "[id:"+transazioneApplicativoServer.getIdTransazione()+"][sa:"+transazioneApplicativoServer.getServizioApplicativoErogatore()+"]["+transazioneApplicativoServer.getConnettoreNome()+"] 'gestisciErroreAggiornamentoInformazioneConsegnaTerminata'";
  802.                         
  803.                         boolean existsTransaction = false;
  804.                         try {
  805.                             existsTransaction = TransactionServerUtils.existsTransaction(transazioneApplicativoServer.getIdTransazione(), con, this.tipoDatabase, this.log, 
  806.                                     true); // la sessione viene chiusa dopo
  807.                         }catch(Throwable t) {
  808.                             String msgError = prefix+" compresione esistenza transazione fallita";
  809.                             this.log.error(msgError, t);
  810.                         }
  811.                         
  812.                         boolean serializeTransactionInfo = false;
  813.                         try {
  814.                             serializeTransactionInfo = true;
  815.                             try{
  816.                                 if(transazioneApplicativoServer.getIdTransazione()!=null && transazioneApplicativoServer.getServizioApplicativoErogatore()!=null) {
  817.                                     // NOTA: volutamente salvo serverInfo per poter reimplementare la logica di cui sopra
  818.                                     transazioneApplicativoServer.setProtocollo(protocol);
  819.                                     /**System.out.println("["+transazioneApplicativoServer.getConnettoreNome()+"] ["+transazioneApplicativoServer.getIdTransazione()+"] SAVE PER RECUPERO");*/
  820.                                     exceptionSerializerFileSystem.registrazioneFileSystemTransazioneApplicativoServerConsegnaTerminata(transazioneApplicativoServer, transazioneApplicativoServer.getIdTransazione(), transazioneApplicativoServer.getServizioApplicativoErogatore());
  821.                                 }
  822.                             } catch (Throwable eClose) {
  823.                                 // ignore
  824.                             }
  825.                             
  826.                         }catch(Throwable t) {
  827.                             String msgError = prefix+" compresione esistenza transazione fallita";
  828.                             this.log.error(msgError,t );
  829.                         }
  830.                         
  831.                         String msgError = prefix+" effettuata gestione dell'errore (existsTransaction="+existsTransaction+" serializeTransactionInfo="+serializeTransactionInfo+")";
  832.                         this.log.error(msgError);
  833.                         
  834.                     }
  835.                 }finally {  
  836.                     if(times!=null) {
  837.                         long timeEnd =  DateManager.getTimeMillis();
  838.                         long timeProcess = timeEnd-timeStart;
  839.                         times.updateTransazione = timeProcess;
  840.                     }
  841.                 }
  842.             }
  843.             
  844.             try{
  845.                 if(con!=null) {
  846.                     con.setAutoCommit(true);
  847.                 }
  848.             }catch(Exception eRollback){
  849.                 // ignore
  850.             }
  851.             try {
  852.                 if(!useConnectionRuntime) {
  853.                     if(dbManagerTransazioni!=null) {
  854.                         dbManagerTransazioni.releaseResource(idDominio, ID_MODULO, dbResource);
  855.                     }
  856.                     else if(dbConsegnePreseInCaricoManager!=null) {
  857.                         dbConsegnePreseInCaricoManager.releaseResource(idDominio, ID_MODULO, dbResource);
  858.                     }
  859.                     else if(dbConsegneMessageBoxManager!=null){
  860.                         dbConsegneMessageBoxManager.releaseResource(idDominio, ID_MODULO, dbResource);
  861.                     }
  862.                 }
  863.             } catch (Exception e) {
  864.                 // ignore
  865.             }
  866.         }


  869.     }

  871.     private void setDettaglioEsito(TransazioneApplicativoServer transazioneApplicativoServer, EsitiProperties esitiProperties, Context context) throws ProtocolException {
  872.         
  873.         if(transazioneApplicativoServer.getDataMessaggioScaduto()!=null) {
  874.             return; // non devo aggiornare l'esito
  875.         }
  876.         else if(transazioneApplicativoServer.getDataPrelievoIm()!=null) {
  877.             return; // non devo aggiornare l'esito
  878.         }
  879.         else if(transazioneApplicativoServer.getDataEliminazioneIm()!=null) {
  880.             transazioneApplicativoServer.setDettaglioEsito(esitiProperties.convertoToCode(EsitoTransazioneName.OK));
  881.         }
  882.         else {
  883.             if(transazioneApplicativoServer.getDataUscitaRichiesta()!=null) {
  884.                 if(transazioneApplicativoServer.getFault()!=null) {
  885.                     transazioneApplicativoServer.setDettaglioEsito(esitiProperties.convertoToCode(EsitoTransazioneName.ERRORE_APPLICATIVO));
  886.                 }
  887.                 else if(transazioneApplicativoServer.getCodiceRisposta()!=null) {
  888.                     int code = -1;
  889.                     try {
  890.                         code = Integer.valueOf(transazioneApplicativoServer.getCodiceRisposta());
  891.                     }catch(Exception e) {
  892.                         // ignore
  893.                     }
  894.                     if(code>0) {
  895.                         if(code<=299) {
  896.                             transazioneApplicativoServer.setDettaglioEsito(esitiProperties.convertoToCode(EsitoTransazioneName.OK));
  897.                         }
  898.                         else if(transazioneApplicativoServer.isConsegnaTerminata()) {
  899.                             
  900.                             if(code>299 && code<=399) {
  901.                                 transazioneApplicativoServer.setDettaglioEsito(esitiProperties.convertoToCode(EsitoTransazioneName.HTTP_3xx));
  902.                             }
  903.                             else if(code>399 && code<=499) {
  904.                                 transazioneApplicativoServer.setDettaglioEsito(esitiProperties.convertoToCode(EsitoTransazioneName.HTTP_4xx));
  905.                             }
  906.                             else { /**if(code>499) {*/
  907.                                 transazioneApplicativoServer.setDettaglioEsito(esitiProperties.convertoToCode(EsitoTransazioneName.HTTP_5xx));
  908.                             }
  909.                             
  910.                         }
  911.                         else {
  912.                             setErroreInvocazione(transazioneApplicativoServer, esitiProperties, context, code);
  913.                         }
  914.                     }
  915.                     else {
  916.                         // altro tipo di codice
  917.                         if(transazioneApplicativoServer.isConsegnaTerminata()) {
  918.                             transazioneApplicativoServer.setDettaglioEsito(esitiProperties.convertoToCode(EsitoTransazioneName.OK));
  919.                         }
  920.                         else {
  921.                             setErroreInvocazione(transazioneApplicativoServer, esitiProperties, context, -1);
  922.                         }
  923.                     }
  924.                 }
  925.                 else {
  926.                     // senza codice di risposta
  927.                     if(transazioneApplicativoServer.isConsegnaTerminata()) {
  928.                         transazioneApplicativoServer.setDettaglioEsito(esitiProperties.convertoToCode(EsitoTransazioneName.OK));
  929.                     }
  930.                     else {
  931.                         setErroreInvocazione(transazioneApplicativoServer, esitiProperties, context, -1);
  932.                     }
  933.                 }
  934.             }
  935.         }
  936.         
  937.         if(transazioneApplicativoServer.getDettaglioEsito()>0) {
  938.             // nop
  939.         }
  940.         
  941.     }
  942.     
  943.     private void setErroreInvocazione(TransazioneApplicativoServer transazioneApplicativoServer, EsitiProperties esitiProperties, Context context, int code) throws ProtocolException {
  944.         EsitoTransazioneName name = EsitoTransazioneName.ERRORE_INVOCAZIONE;
  945.         if(context!=null &&
  946.                 context.containsKey(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_NAME_CONTROLLO_TRAFFICO_VIOLAZIONE)
  947.             ){

  949.             String timeoutExceededMessage = null;
  950.             if(context.containsKey(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_NAME_CONTROLLO_TRAFFICO_VIOLAZIONE)) {
  951.                 timeoutExceededMessage = (String) context.get(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_NAME_CONTROLLO_TRAFFICO_VIOLAZIONE);
  952.                 if(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_VALUE_CONNECTION_TIMEOUT.equals(timeoutExceededMessage)) {
  953.                     name = EsitoTransazioneName.ERRORE_CONNECTION_TIMEOUT;
  954.                 }
  955.                 else if(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_VALUE_REQUEST_READ_TIMEOUT.equals(timeoutExceededMessage)) {
  956.                     name = EsitoTransazioneName.ERRORE_REQUEST_TIMEOUT;
  957.                 }
  958.                 else if(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_VALUE_RESPONSE_READ_TIMEOUT.equals(timeoutExceededMessage) ||
  959.                         org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_VALUE_READ_TIMEOUT.equals(timeoutExceededMessage)) {
  960.                     name = EsitoTransazioneName.ERRORE_RESPONSE_TIMEOUT;
  961.                 }
  962.             }
  963.             
  964.         }
  965.         else {
  966.             if(code>299 && code<=399) {
  967.                 name = EsitoTransazioneName.HTTP_3xx;
  968.             }
  969.             else if(code>399 && code<=499) {
  970.                 name = EsitoTransazioneName.HTTP_4xx;
  971.             }
  972.             else if(code>499 && code<=599) {
  973.                 name = EsitoTransazioneName.HTTP_5xx;
  974.             }
  975.         }
  976.         
  977.         transazioneApplicativoServer.setDettaglioEsito(esitiProperties.convertoToCode(name));
  978.     }

  980.     private static boolean debugStaticValue = true;
  981.     public static boolean isDebug() {
  982.         return debugStaticValue;
  983.     }
  984.     public static void setDebug(boolean debug) {
  985.         GestoreConsegnaMultipla.debugStaticValue = debug;
  986.     }
  987.     private boolean safeAggiornaInformazioneConsegnaTerminata(TransazioneApplicativoServer transazioneApplicativoServer, Connection con, EsitiProperties esitiProperties,
  988.              boolean possibileTerminazioneSingleIntegrationManagerMessage,boolean consegnaInErrore,
  989.              List<String> timeDetails) {
  990.         
  991.         boolean debugMode = debugStaticValue; // un eventuale errore deve essere sempre registrato
  992.         
  993.         DAOFactory daoF = debugMode ? daoFactory : daoFactoryDevNull;
  994.         Logger logFactory = debugMode ? daoFactoryLoggerTransazioniSql : daoFactoryLoggerTransazioniDevNull;
  995.         ServiceManagerProperties smp = debugMode ? daoFactoryServiceManagerPropertiesTransazioni : daoFactoryDevNullServiceManagerPropertiesTransazioni;
  996.         
  997.         int esitoConsegnaMultipla = -1;
  998.         int esitoConsegnaMultiplaInCorso = -1;
  999.         int esitoConsegnaMultiplaFallita = -1;
  1000.         int esitoConsegnaMultiplaCompletata = -1;
  1001.         int ok = -1;
  1002.         int esitoIntegrationManagerSingolo = -1;
  1003.         boolean esitiLetti = false;
  1004.         try {
  1005.             esitoConsegnaMultipla = esitiProperties.convertoToCode(EsitoTransazioneName.CONSEGNA_MULTIPLA);
  1006.             esitoConsegnaMultiplaInCorso = esitiProperties.convertoToCode(EsitoTransazioneName.CONSEGNA_MULTIPLA_IN_CORSO);
  1007.             esitoConsegnaMultiplaFallita = esitiProperties.convertoToCode(EsitoTransazioneName.CONSEGNA_MULTIPLA_FALLITA);
  1008.             esitoConsegnaMultiplaCompletata = esitiProperties.convertoToCode(EsitoTransazioneName.CONSEGNA_MULTIPLA_COMPLETATA);
  1009.             ok = esitiProperties.convertoToCode(EsitoTransazioneName.OK);
  1010.             esitoIntegrationManagerSingolo = esitiProperties.convertoToCode(EsitoTransazioneName.MESSAGE_BOX);
  1011.             esitiLetti = true;          
  1012.         }catch(Exception er) {
  1013.             // errore che non dovrebbe succedere
  1014.             String msg = "Errore durante l'aggiornamento delle transazione relativamente all'informazione del server '"+transazioneApplicativoServer.getServizioApplicativoErogatore()+"': (readEsiti) " + er.getMessage();
  1015.             this.log.error("[id:"+transazioneApplicativoServer.getIdTransazione()+"][sa:"+transazioneApplicativoServer.getServizioApplicativoErogatore()+"]["+transazioneApplicativoServer.getConnettoreNome()+"] "+msg,er);
  1016.         }
  1017.         
  1018.         if(esitiLetti) {
  1019.             return TransactionServerUtils.safeAggiornaInformazioneConsegnaTerminata(transazioneApplicativoServer, con, 
  1020.                     this.tipoDatabase, this.log,
  1021.                     daoF,logFactory,smp,
  1022.                     this.debug,
  1023.                     esitoConsegnaMultipla, esitoConsegnaMultiplaInCorso, esitoConsegnaMultiplaFallita, esitoConsegnaMultiplaCompletata, ok,
  1024.                     esitoIntegrationManagerSingolo, possibileTerminazioneSingleIntegrationManagerMessage, consegnaInErrore,
  1025.                     openspcoopProperties.getGestioneSerializableDBAttesaAttiva(),openspcoopProperties.getGestioneSerializableDBCheckInterval(),
  1026.                     timeDetails);
  1027.         }
  1028.         return false;
  1029.     }

  1031. }

  1033. class TransazioniSAProcessTimes{

  1035.     String idTransazione;
  1036.     String servizioApplicativoErogatore;
  1037.     long getConnection = -1;
  1038.     long insert = -1;
  1039.     long update = -1;
  1040.     List<String> saDetails = null;
  1041.     long updateTransazione = -1;
  1042.     List<String> transazioneDetails = null;
  1043.     
  1044.     @Override
  1045.     public String toString() {
  1046.         StringBuilder sb = new StringBuilder();
  1047.         if(this.getConnection>=0) {
  1048.             if(sb.length()>0) {
  1049.                 sb.append(" ");
  1050.             }
  1051.             sb.append("getConnection:").append(this.getConnection);
  1052.         }
  1053.         if(this.insert>=0) {
  1054.             if(sb.length()>0) {
  1055.                 sb.append(" ");
  1056.             }
  1057.             sb.append("insert:").append(this.insert);
  1058.         }
  1059.         if(this.update>=0) {
  1060.             if(sb.length()>0) {
  1061.                 sb.append(" ");
  1062.             }
  1063.             sb.append("update:").append(this.update);
  1064.         }
  1065.         if(this.saDetails!=null && !this.saDetails.isEmpty()) {
  1066.             if(sb.length()>0) {
  1067.                 sb.append(" ");
  1068.             }
  1069.             if(this.insert>=0) {
  1070.                 sb.append("insertDetails:{");
  1071.             }
  1072.             else if(this.update>=0) {
  1073.                 sb.append("updateDetails:{");
  1074.             }
  1075.             else {
  1076.                 sb.append("details:{");
  1077.             }
  1078.             boolean first = true;
  1079.             for (String det : this.saDetails) {
  1080.                 if(!first) {
  1081.                     sb.append(" ");
  1082.                 }
  1083.                 sb.append(det);
  1084.                 first=false;
  1085.             }
  1086.             sb.append("}");
  1087.         }
  1088.         if(this.updateTransazione>=0) {
  1089.             if(sb.length()>0) {
  1090.                 sb.append(" ");
  1091.             }
  1092.             sb.append("updateTransaction:").append(this.updateTransazione);
  1093.         }
  1094.         if(this.transazioneDetails!=null && !this.transazioneDetails.isEmpty()) {
  1095.             if(sb.length()>0) {
  1096.                 sb.append(" ");
  1097.             }
  1098.             sb.append("updateTransactionDetails:{");
  1099.             boolean first = true;
  1100.             for (String det : this.transazioneDetails) {
  1101.                 if(!first) {
  1102.                     sb.append(" ");
  1103.                 }
  1104.                 sb.append(det);
  1105.                 first=false;
  1106.             }
  1107.             sb.append("}");
  1108.         }
  1109.         return sb.toString();
  1110.     }
  1111. }
Created with JaCoCo 0.8.8.202204050719