TracciamentoManager.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.logger.transazioni;

  23. import java.io.File;
  24. import java.sql.Connection;
  25. import java.sql.SQLException;
  26. import java.util.ArrayList;
  27. import java.util.Date;
  28. import java.util.HashMap;
  29. import java.util.List;

  31. import org.openspcoop2.core.commons.CoreException;
  32. import org.openspcoop2.core.commons.dao.DAOFactory;
  33. import org.openspcoop2.core.commons.dao.DAOFactoryProperties;
  34. import org.openspcoop2.core.config.OpenspcoopAppender;
  35. import org.openspcoop2.core.config.PortaApplicativa;
  36. import org.openspcoop2.core.config.PortaDelegata;
  37. import org.openspcoop2.core.config.Property;
  38. import org.openspcoop2.core.config.utils.OpenSPCoopAppenderUtilities;
  39. import org.openspcoop2.core.constants.Costanti;
  40. import org.openspcoop2.core.constants.CostantiLabel;
  41. import org.openspcoop2.core.constants.TipoPdD;
  42. import org.openspcoop2.core.controllo_traffico.beans.MisurazioniTransazione;
  43. import org.openspcoop2.core.id.IDPortaApplicativa;
  44. import org.openspcoop2.core.id.IDPortaDelegata;
  45. import org.openspcoop2.core.id.IDServizio;
  46. import org.openspcoop2.core.id.IDSoggetto;
  47. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  48. import org.openspcoop2.core.transazioni.Transazione;
  49. import org.openspcoop2.core.transazioni.constants.DiagnosticColumnType;
  50. import org.openspcoop2.core.transazioni.dao.IDumpMessaggioService;
  51. import org.openspcoop2.core.transazioni.dao.ITransazioneService;
  52. import org.openspcoop2.core.transazioni.utils.TransazioneDaoExt;
  53. import org.openspcoop2.generic_project.beans.UpdateField;
  54. import org.openspcoop2.generic_project.exception.ExpressionException;
  55. import org.openspcoop2.generic_project.exception.ExpressionNotImplementedException;
  56. import org.openspcoop2.generic_project.exception.NotFoundException;
  57. import org.openspcoop2.generic_project.exception.NotImplementedException;
  58. import org.openspcoop2.generic_project.exception.ServiceException;
  59. import org.openspcoop2.generic_project.expression.IExpression;
  60. import org.openspcoop2.generic_project.utils.ServiceManagerProperties;
  61. import org.openspcoop2.monitor.sdk.transaction.FaseTracciamento;
  62. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  63. import org.openspcoop2.pdd.config.DBTransazioniManager;
  64. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  65. import org.openspcoop2.pdd.config.Resource;
  66. import org.openspcoop2.pdd.core.CostantiPdD;
  67. import org.openspcoop2.pdd.core.controllo_traffico.CostantiControlloTraffico;
  68. import org.openspcoop2.pdd.core.controllo_traffico.handler.PostOutResponseHandlerGestioneControlloTraffico;
  69. import org.openspcoop2.pdd.core.handlers.HandlerException;
  70. import org.openspcoop2.pdd.core.handlers.transazioni.ExceptionSerialzerFileSystem;
  71. import org.openspcoop2.pdd.core.handlers.transazioni.ISalvataggioDiagnosticiManager;
  72. import org.openspcoop2.pdd.core.handlers.transazioni.ISalvataggioTracceManager;
  73. import org.openspcoop2.pdd.core.handlers.transazioni.StatoSalvataggioDiagnostici;
  74. import org.openspcoop2.pdd.core.handlers.transazioni.StatoSalvataggioTracce;
  75. import org.openspcoop2.pdd.core.token.InformazioniNegoziazioneToken;
  76. import org.openspcoop2.pdd.core.token.InformazioniToken;
  77. import org.openspcoop2.pdd.core.token.attribute_authority.InformazioniAttributi;
  78. import org.openspcoop2.pdd.core.transazioni.Transaction;
  79. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  80. import org.openspcoop2.pdd.core.transazioni.TransactionNotExistsException;
  81. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  82. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  83. import org.openspcoop2.pdd.logger.filetrace.FileTraceConfig;
  84. import org.openspcoop2.pdd.logger.filetrace.FileTraceManager;
  85. import org.openspcoop2.pdd.services.ServicesUtils;
  86. import org.openspcoop2.protocol.engine.SecurityTokenUtilities;
  87. import org.openspcoop2.protocol.sdk.Context;
  88. import org.openspcoop2.protocol.sdk.SecurityToken;
  89. import org.openspcoop2.protocol.sdk.builder.EsitoTransazione;
  90. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  91. import org.openspcoop2.protocol.sdk.diagnostica.IDiagnosticProducer;
  92. import org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico;
  93. import org.openspcoop2.protocol.sdk.dump.IDumpProducer;
  94. import org.openspcoop2.protocol.sdk.dump.Messaggio;
  95. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  96. import org.openspcoop2.protocol.sdk.tracciamento.ITracciaProducer;
  97. import org.openspcoop2.protocol.sdk.tracciamento.Traccia;
  98. import org.openspcoop2.utils.BooleanNullable;
  99. import org.openspcoop2.utils.Map;
  100. import org.openspcoop2.utils.MapKey;
  101. import org.openspcoop2.utils.date.DateManager;
  102. import org.openspcoop2.utils.date.DateUtils;
  103. import org.openspcoop2.utils.date.UnitaTemporale;
  104. import org.slf4j.Logger;

  106. /**
  107.  * TracciamentoManager
  108.  * 
  109.  * @author Andrea Poli (apoli@link.it)
  110.  * @author $Author$
  111.  * @version $Rev$, $Date$
  112.  * 
  113.  */
  114. public class TracciamentoManager {

  116.     private boolean transazioniEnabled = true;
  117.     public boolean isTransazioniEnabled() {
  118.         return this.transazioniEnabled;
  119.     }
  120.     
  121.     /**
  122.      * Database resources
  123.      */
  124.     private DAOFactory daoFactory = null;
  125.     private ServiceManagerProperties daoFactoryServiceManagerPropertiesTransazioni = null;
  126.     private Logger daoFactoryLoggerTransazioni = null;

  128.     /**
  129.      * OpenSPCoop2Properties/ConfigurazionePdDManager resources
  130.      */
  131.     private OpenSPCoop2Properties openspcoopProperties = null;
  132.     public OpenSPCoop2Properties getOpenspcoopProperties() {
  133.         return this.openspcoopProperties;
  134.     }
  135.     private ConfigurazionePdDManager configPdDManager = null;
  136.     
  137.     /**
  138.      * Indicazione se funzionare in modalita' debug
  139.      */
  140.     private boolean debug = false;

  142.     /**
  143.      * Tracciamento e MsgDiagnostici appender
  144.      */
  145.     private ITracciaProducer tracciamentoOpenSPCoopAppender = null;
  146.     private IDiagnosticProducer msgDiagnosticiOpenSPCoopAppender = null;
  147.     private IDumpProducer dumpOpenSPCoopAppender = null;

  149.     /**
  150.      * Informazioni tracce e diagnostici
  151.      */
  152.     private boolean transazioniRegistrazioneTracceProtocolPropertiesEnabled = false;
  153.     private boolean transazioniRegistrazioneTracceHeaderRawEnabled = false;
  154.     private boolean transazioniRegistrazioneTracceDigestEnabled = false;
  155.     private ISalvataggioTracceManager salvataggioTracceManager = null;
  156.     private ISalvataggioDiagnosticiManager salvataggioDiagnosticiManager = null;
  157.     private boolean transazioniRegistrazioneDumpHeadersCompactEnabled = false;
  158.     
  159.     private FaseTracciamento fase;
  160.     private boolean usePdDConnection = true;
  161.     private String tipoDatabaseRuntime = null;
  162.     
  163.     /**
  164.      * Logger
  165.      */
  166.     private Logger log = null;
  167.     public void logDebug(String msg) {
  168.         if(this.log!=null) {
  169.             this.log.debug(msg);
  170.         }
  171.     }
  172.     public void logDebug(String msg, Exception e) {
  173.         if(this.log!=null) {
  174.             this.log.debug(msg,e);
  175.         }
  176.     }
  177.     public void logWarn(String msg) {
  178.         if(this.log!=null) {
  179.             this.log.warn(msg);
  180.         }
  181.     }
  182.     public void logError(String msg) {
  183.         if(this.log!=null) {
  184.             this.log.error(msg);
  185.         }
  186.     }
  187.     public void logError(String msg, Throwable e) {
  188.         if(this.log!=null) {
  189.             this.log.error(msg,e);
  190.         }
  191.     }
  192.     private Logger logSql = null;
  193.     public void logSqlDebug(String msg) {
  194.         if(this.logSql!=null) {
  195.             this.logSql.debug(msg);
  196.         }
  197.     }
  198.     
  199.     private static final String TIPO_RECOVERY_FS = "__timerFileSystemRecovery";
  200.     
  201.     public TracciamentoManager(FaseTracciamento fase) throws CoreException{
  202.         this.fase = fase;
  203.         
  204.         this.openspcoopProperties = OpenSPCoop2Properties.getInstance();
  205.         this.transazioniEnabled = this.openspcoopProperties.isTransazioniEnabled();
  206.         if(!this.transazioniEnabled) {
  207.             return;
  208.         }
  209.         
  210.         // Debug
  211.         this.debug = this.openspcoopProperties.isTransazioniDebug();
  212.         
  213.         // Log
  214.         this.log = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioni(this.debug);
  215.         this.logSql = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniSql(this.debug);
  216.         
  217.         this.tipoDatabaseRuntime = this.openspcoopProperties.getDatabaseType();
  218.         if(this.tipoDatabaseRuntime==null){
  219.             throw new CoreException("Tipo Database non definito");
  220.         }
  221.         
  222.         this.configPdDManager = ConfigurazionePdDManager.getInstance();
  223.         
  224.         this.initTransactionResources();
  225.         
  226.         this.usePdDConnection = true;
  227.         
  228.         if(FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)) {
  229.             initTracciamento(this.tipoDatabaseRuntime, this.usePdDConnection);
  230.         }
  231.         
  232.         if(FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)) {
  233.             initDiagnostica(this.tipoDatabaseRuntime, this.usePdDConnection);
  234.             initDump(this.tipoDatabaseRuntime, this.usePdDConnection);
  235.         }
  236.         
  237.         initConfigurazioneTracciamento();
  238.     }
  239.     
  240.     private void initTransactionResources() throws CoreException {
  241.         // DB
  242.         try{
  243.             DAOFactoryProperties daoFactoryProperties = null;
  244.             this.daoFactoryLoggerTransazioni = this.logSql;
  245.             this.daoFactory = DAOFactory.getInstance(this.daoFactoryLoggerTransazioni);
  246.             daoFactoryProperties = DAOFactoryProperties.getInstance(this.daoFactoryLoggerTransazioni);
  247.             this.daoFactoryServiceManagerPropertiesTransazioni = daoFactoryProperties.getServiceManagerProperties(org.openspcoop2.core.transazioni.utils.ProjectInfo.getInstance());
  248.             this.daoFactoryServiceManagerPropertiesTransazioni.setShowSql(this.debug);  
  249.             this.daoFactoryServiceManagerPropertiesTransazioni.setDatabaseType(DBTransazioniManager.getInstance().getTipoDatabase());

  251.         }catch(Exception e){
  252.             throw new CoreException("Errore durante l'inizializzazione delle risorse per l'accesso al database: "+e.getMessage(),e);
  253.         }
  254.     }
  255.     
  256.     private void initTracciamento(String tipoDatabaseRuntime, boolean usePdDConnection) throws CoreException {
  257.         try{
  258.             
  259.             // Init
  260.             this.tracciamentoOpenSPCoopAppender = new org.openspcoop2.pdd.logger.TracciamentoOpenSPCoopProtocolAppender();
  261.             OpenspcoopAppender tracciamentoOpenSPCoopAppenderEngine = new OpenspcoopAppender();
  262.             tracciamentoOpenSPCoopAppenderEngine.setTipo(TIPO_RECOVERY_FS);
  263.             List<Property> tracciamentoOpenSPCoopAppenderProperties = new ArrayList<>();

  265.             // Verra poi utilizzata la connessione ottenuta ogni volta che il timer viene eseguito, infatti si usa usePdDConnection
  266.             OpenSPCoopAppenderUtilities.addParameters(this.daoFactoryLoggerTransazioni, tracciamentoOpenSPCoopAppenderProperties, 
  267.                     null, // nessun datasource
  268.                     null, null, null, null,  // nessuna connection
  269.                     tipoDatabaseRuntime,
  270.                     usePdDConnection, // viene usata la connessione della PdD 
  271.                     this.debug
  272.                     );
  273.             OpenSPCoopAppenderUtilities.addCheckProperties(tracciamentoOpenSPCoopAppenderProperties, false);

  275.             tracciamentoOpenSPCoopAppenderEngine.setPropertyList(tracciamentoOpenSPCoopAppenderProperties);
  276.             this.tracciamentoOpenSPCoopAppender.initializeAppender(tracciamentoOpenSPCoopAppenderEngine);
  277.             this.tracciamentoOpenSPCoopAppender.isAlive();
  278.             
  279.         }catch(Exception e){
  280.             throw new CoreException("Errore durante l'inizializzazione del TracciamentoAppender: "+e.getMessage(),e);
  281.         } 
  282.     }
  283.     
  284.     private void initDiagnostica(String tipoDatabaseRuntime, boolean usePdDConnection) throws CoreException {
  285.         try{
  286.             
  287.             // Init
  288.             this.msgDiagnosticiOpenSPCoopAppender = new org.openspcoop2.pdd.logger.MsgDiagnosticoOpenSPCoopProtocolAppender();
  289.             OpenspcoopAppender diagnosticoOpenSPCoopAppenderEngine = new OpenspcoopAppender();
  290.             diagnosticoOpenSPCoopAppenderEngine.setTipo(TIPO_RECOVERY_FS);
  291.             List<Property> diagnosticoOpenSPCoopAppenderProperties = new ArrayList<>();

  293.             // Verra poi utilizzata la connessione ottenuta ogni volta che il timer viene eseguito, infatti si usa usePdDConnection
  294.             OpenSPCoopAppenderUtilities.addParameters(this.daoFactoryLoggerTransazioni, diagnosticoOpenSPCoopAppenderProperties, 
  295.                     null, // nessun datasource
  296.                     null, null, null, null,  // nessuna connection
  297.                     tipoDatabaseRuntime,
  298.                     usePdDConnection, // viene usata la connessione della PdD
  299.                     this.debug
  300.                     );
  301.             OpenSPCoopAppenderUtilities.addCheckProperties(diagnosticoOpenSPCoopAppenderProperties, false);

  303.             diagnosticoOpenSPCoopAppenderEngine.setPropertyList(diagnosticoOpenSPCoopAppenderProperties);
  304.             this.msgDiagnosticiOpenSPCoopAppender.initializeAppender(diagnosticoOpenSPCoopAppenderEngine);
  305.             this.msgDiagnosticiOpenSPCoopAppender.isAlive();
  306.             
  307.         }catch(Exception e){
  308.             throw new CoreException("Errore durante l'inizializzazione del DiagnosticoAppender: "+e.getMessage(),e);
  309.         } 
  310.     }
  311.     
  312.     private void initDump(String tipoDatabaseRuntime, boolean usePdDConnection) throws CoreException {
  313.         try{
  314.             
  315.             // Init
  316.             this.dumpOpenSPCoopAppender = new org.openspcoop2.pdd.logger.DumpOpenSPCoopProtocolAppender();
  317.             OpenspcoopAppender dumpOpenSPCoopAppenderEngine = new OpenspcoopAppender();
  318.             dumpOpenSPCoopAppenderEngine.setTipo(TIPO_RECOVERY_FS);
  319.             List<Property> dumpOpenSPCoopAppenderProperties = new ArrayList<>();

  321.             // Verra poi utilizzata la connessione ottenuta ogni volta che il timer viene eseguito, infatti si usa usePdDConnection
  322.             OpenSPCoopAppenderUtilities.addParameters(this.daoFactoryLoggerTransazioni, dumpOpenSPCoopAppenderProperties, 
  323.                     null, // nessun datasource
  324.                     null, null, null, null,  // nessuna connection
  325.                     tipoDatabaseRuntime,
  326.                     usePdDConnection, // viene usata la connessione della PdD 
  327.                     this.debug
  328.                     );
  329.             OpenSPCoopAppenderUtilities.addCheckProperties(dumpOpenSPCoopAppenderProperties, false);

  331.             dumpOpenSPCoopAppenderEngine.setPropertyList(dumpOpenSPCoopAppenderProperties);
  332.             this.dumpOpenSPCoopAppender.initializeAppender(dumpOpenSPCoopAppenderEngine);
  333.             this.dumpOpenSPCoopAppender.isAlive();
  334.             
  335.         }catch(Exception e){
  336.             throw new CoreException("Errore durante l'inizializzazione del DumpAppender: "+e.getMessage(),e);
  337.         } 
  338.     }
  339.     
  340.     private void initConfigurazioneTracciamento() throws CoreException {
  341.         // Configurazione tracce e diagnostici
  342.         try{

  344.             // Indicazione se devo registrare tutte le tracce o solo quelle non ricostruibili
  345.             this.transazioniRegistrazioneTracceProtocolPropertiesEnabled =  this.openspcoopProperties.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled();
  346.             this.transazioniRegistrazioneTracceHeaderRawEnabled = this.openspcoopProperties.isTransazioniRegistrazioneTracceHeaderRawEnabled();
  347.             this.transazioniRegistrazioneTracceDigestEnabled = this.openspcoopProperties.isTransazioniRegistrazioneTracceDigestEnabled();
  348.             
  349.             // Indicazioni sulle modalita' di salvataggio degli header del dump
  350.             this.transazioniRegistrazioneDumpHeadersCompactEnabled = this.openspcoopProperties.isTransazioniRegistrazioneDumpHeadersCompactEnabled();
  351.             
  352.             // salvataggio
  353.             this.salvataggioTracceManager = this.openspcoopProperties.getTransazioniRegistrazioneTracceManager();
  354.             this.salvataggioDiagnosticiManager = this.openspcoopProperties.getTransazioniRegistrazioneDiagnosticiManager();

  356.         } catch (Exception e) {
  357.             throw new CoreException("Errore durante la lettura della configurazione della registrazione di tracce/diagnostici: " + e.getLocalizedMessage(), e);
  358.         }
  359.     }
  360.     
  361.     
  362.     private static final MapKey<String> DISABLE_TRANSACTION_FILTER = Map.newMapKey("DISABLE_TRANSACTION_FILTER");
  363.     private boolean existsTransactionFilter(InformazioniTransazione info) {
  364.         return info!=null && info.getContext()!=null && info.getContext().containsKey(DISABLE_TRANSACTION_FILTER);
  365.     }
  366.     private String getTransactionFilter(InformazioniTransazione info) {
  367.         return (info!=null && info.getContext()!=null) ? (String) info.getContext().get(DISABLE_TRANSACTION_FILTER) : null;
  368.     }
  369.     private void disableTransactionFilter(InformazioniTransazione info) {
  370.         if(!existsTransactionFilter(info) && info!=null && info.getContext()!=null) {
  371.             info.getContext().put(DISABLE_TRANSACTION_FILTER, this.fase.name());
  372.         }
  373.     }
  374.     
  375.     private static final MapKey<String> DISABLE_TRANSACTION_FILTER_DB = Map.newMapKey("DISABLE_TRANSACTION_FILTER_DB");
  376.     private boolean existsTransactionFilterDB(InformazioniTransazione info) {
  377.         return info!=null && info.getContext()!=null && info.getContext().containsKey(DISABLE_TRANSACTION_FILTER_DB);
  378.     }
  379.     private void disableTransactionFilterDB(InformazioniTransazione info) {
  380.         if(!existsTransactionFilter(info) && info!=null && info.getContext()!=null) {
  381.             info.getContext().put(DISABLE_TRANSACTION_FILTER_DB, this.fase.name());
  382.         }
  383.     }
  384.     
  385.     private static final MapKey<String> DISABLE_TRANSACTION_FILTER_FILETRACE = Map.newMapKey("DISABLE_TRANSACTION_FILTER_FILETRACE");
  386.     private boolean existsTransactionFilterFileTrace(InformazioniTransazione info) {
  387.         return info!=null && info.getContext()!=null && info.getContext().containsKey(DISABLE_TRANSACTION_FILTER_FILETRACE);
  388.     }
  389.     private void disableTransactionFilterFileTrace(InformazioniTransazione info) {
  390.         if(!existsTransactionFilter(info) && info!=null && info.getContext()!=null) {
  391.             info.getContext().put(DISABLE_TRANSACTION_FILTER_FILETRACE, this.fase.name());
  392.         }
  393.     }
  394.     
  395.     
  396.     public void invoke(InformazioniTransazione info, String esitoContext, java.util.Map<String, List<String>> headerInUscita,
  397.             org.openspcoop2.pdd.logger.MsgDiagnostico msgdiagErrore) throws HandlerException {
  398.         invokeEngine(info, null, esitoContext, headerInUscita,
  399.                 msgdiagErrore);
  400.     }
  401.     public void invoke(InformazioniTransazione info, String esitoContext,
  402.             org.openspcoop2.pdd.logger.MsgDiagnostico msgdiagErrore) throws HandlerException {
  403.         invokeEngine(info, null, esitoContext, null,
  404.                 msgdiagErrore);
  405.     }
  406.     public void invoke(InformazioniTransazione info, EsitoTransazione esito, java.util.Map<String, List<String>> headerInUscita,
  407.             org.openspcoop2.pdd.logger.MsgDiagnostico msgdiagErrore) throws HandlerException {
  408.         invokeEngine(info, esito, null, headerInUscita,
  409.                 msgdiagErrore);
  410.     }
  411.     public void invoke(InformazioniTransazione info, EsitoTransazione esito) throws HandlerException {
  412.         invokeEngine(info, esito, null, null, null);
  413.     }
  414.     private void invokeEngine(InformazioniTransazione info, EsitoTransazione esito, String esitoContext,
  415.             java.util.Map<String, List<String>> headerInUscita,
  416.             org.openspcoop2.pdd.logger.MsgDiagnostico msgdiagErrore) throws HandlerException {
  417.         
  418.         if(!this.transazioniEnabled) {
  419.             return;
  420.         }
  421.         
  422.         TransazioniProcessTimes times = null;
  423.         long timeStart = -1;
  424.         if(this.openspcoopProperties.isTransazioniRegistrazioneSlowLog()) {
  425.             times = new TransazioniProcessTimes();
  426.             timeStart = DateManager.getTimeMillis();
  427.         }
  428.         try {
  429.             invoke(info, esito, esitoContext, headerInUscita, 
  430.                     msgdiagErrore,
  431.                     times);
  432.         }
  433.         catch(HandlerException he) {
  434.             he.setIntegrationFunctionError(IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE);
  435.             throw he;
  436.         }
  437.         finally {
  438.             if(times!=null) {
  439.                 long timeEnd =  DateManager.getTimeMillis();
  440.                 long timeProcess = timeEnd-timeStart;
  441.                 if(timeProcess>=this.openspcoopProperties.getTransazioniRegistrazioneSlowLogThresholdMs()) {
  442.                     StringBuilder sb = new StringBuilder();
  443.                     sb.append(timeProcess);
  444.                     if(times.idTransazione!=null) {
  445.                         sb.append(" <").append(times.idTransazione).append(">");
  446.                     }
  447.                     sb.append(" ["+this.fase+"]");
  448.                     sb.append(" ").append(times.toString());
  449.                     String msg = sb.toString();
  450.                     OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniSlowLog().info(msg);
  451.                 }
  452.             }
  453.         }
  454.         
  455.     }
  456.     private void invoke(InformazioniTransazione info, 
  457.             EsitoTransazione esito, String esitoContext, 
  458.             java.util.Map<String, List<String>> headerInUscita,
  459.             org.openspcoop2.pdd.logger.MsgDiagnostico msgdiagErrore,
  460.             TransazioniProcessTimes times) throws HandlerException {

  462.         if (info==null)
  463.             throw new HandlerException("Informazioni transazione is null");
  464.         
  465.         Context context = info.getContext();
  466.         TipoPdD tipoPorta = info.getTipoPorta();
  467.         

  469.         /* ---- Recupero contesto ----- */

  471.         if (context==null)
  472.             throw new HandlerException("Contesto is null");

  474.         if (context.getObject(Costanti.ID_TRANSAZIONE)==null)
  475.             throw new HandlerException("Identificativo della transazione assente");
  476.         String idTransazione = (String) context.getObject(Costanti.ID_TRANSAZIONE);
  477.         if (idTransazione==null)
  478.             throw new HandlerException("Identificativo della transazione assente");
  479.         /**System.out.println("------------- "+this.fase+" ("+idTransazione+")("+context.getTipoPorta().getTipo()+") -------------------");*/
  480.         String prefixIdTransazione = "Transazione ID["+idTransazione+"] ";

  482.         Transaction transaction = null;
  483.         try {
  484.             transaction = FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase) ? TransactionContext.removeTransaction(idTransazione) : TransactionContext.getTransaction(idTransazione);
  485.         }catch(TransactionNotExistsException n) {
  486.             // ignore
  487.         }
  488.         if(times!=null) {
  489.             times.idTransazione = idTransazione;
  490.         }
  491.         
  492.         /* ---- Verifica Configurazione della Transazione per registrazione nello storico ----- */
  493.         
  494.         ConfigurazioneTracciamento configurazioneTracciamento = null;
  495.         boolean dbEnabledBloccante = true;
  496.         boolean dbEnabledNonBloccante = false;
  497.         boolean fileTraceEnabledBloccante = false;
  498.         boolean fileTraceEnabledNonBloccante = false;
  499.         File fileTraceConfig = null;
  500.         boolean fileTraceConfigGlobal = true;
  501.         boolean existsAnotherFiletraceTrackingPhase = false;
  502.         try{
  503.             if(msgdiagErrore==null) {
  504.                 String nomePorta = null;
  505.                 if(transaction!=null && transaction.getRequestInfo()!=null && 
  506.                         transaction.getRequestInfo().getProtocolContext()!=null &&
  507.                         transaction.getRequestInfo().getProtocolContext().getInterfaceName()!=null) {
  508.                     nomePorta = transaction.getRequestInfo().getProtocolContext().getInterfaceName();
  509.                 }
  510.                 RequestInfo requestInfo = transaction!=null ? transaction.getRequestInfo() : null;
  511.                 msgdiagErrore = org.openspcoop2.pdd.logger.MsgDiagnostico.newInstance(info.getTipoPorta(),info.getIdModulo(), nomePorta, requestInfo, this.configPdDManager);
  512.                 msgdiagErrore.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_BUSTE);
  513.                 msgdiagErrore.setPddContext(info.getContext(), info.getProtocolFactory());
  514.             }
  515.             
  516.             configurazioneTracciamento = getConfigurazioneTracciamento(idTransazione, context, tipoPorta, transaction); 
  517.             
  518.             if(configurazioneTracciamento!=null) {
  519.                 dbEnabledBloccante = configurazioneTracciamento.isDbEnabled();
  520.                 if(dbEnabledBloccante) {
  521.                     switch (this.fase) {
  522.                     case IN_REQUEST:
  523.                         dbEnabledBloccante = configurazioneTracciamento.getRegole()!=null && configurazioneTracciamento.getRegole().isTracciamentoDBRequestInEnabledBloccante();
  524.                         dbEnabledNonBloccante = configurazioneTracciamento.getRegole()!=null && configurazioneTracciamento.getRegole().isTracciamentoDBRequestInEnabledNonBloccante();                      
  525.                         break;
  526.                     case OUT_REQUEST:
  527.                         dbEnabledBloccante = configurazioneTracciamento.getRegole()!=null && configurazioneTracciamento.getRegole().isTracciamentoDBRequestOutEnabledBloccante();
  528.                         dbEnabledNonBloccante = configurazioneTracciamento.getRegole()!=null && configurazioneTracciamento.getRegole().isTracciamentoDBRequestOutEnabledNonBloccante();
  529.                         break;
  530.                     case OUT_RESPONSE:
  531.                         dbEnabledBloccante = configurazioneTracciamento.getRegole()!=null && configurazioneTracciamento.getRegole().isTracciamentoDBResponseOutEnabledBloccante();
  532.                         dbEnabledNonBloccante = configurazioneTracciamento.getRegole()!=null && configurazioneTracciamento.getRegole().isTracciamentoDBResponseOutEnabledNonBloccante();
  533.                         break;
  534.                     case POST_OUT_RESPONSE:
  535.                         dbEnabledBloccante = configurazioneTracciamento.getRegole()==null || configurazioneTracciamento.getRegole().isTracciamentoDBResponseOutCompleteEnabled();
  536.                         break;
  537.                     }
  538.                 }
  539.                 
  540.                 fileTraceEnabledBloccante = configurazioneTracciamento.isFileTraceEnabled();
  541.                 if(fileTraceEnabledBloccante) {
  542.                     fileTraceConfig = configurazioneTracciamento.getFileTraceConfig();
  543.                     fileTraceConfigGlobal = configurazioneTracciamento.isFileTraceConfigGlobal();
  544.                 }
  545.                 if(fileTraceEnabledBloccante) {
  546.                     switch (this.fase) {
  547.                     case IN_REQUEST:
  548.                         fileTraceEnabledBloccante = configurazioneTracciamento.getRegole()!=null && configurazioneTracciamento.getRegole().isTracciamentoFileTraceRequestInEnabledBloccante();
  549.                         fileTraceEnabledNonBloccante = configurazioneTracciamento.getRegole()!=null && configurazioneTracciamento.getRegole().isTracciamentoFileTraceRequestInEnabledNonBloccante();
  550.                         
  551.                         // per ripulire le risorse
  552.                         if(this.openspcoopProperties.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase() && configurazioneTracciamento.isFileTraceEnabled()) {
  553.                             existsAnotherFiletraceTrackingPhase = 
  554.                                     // postOutResponse
  555.                                     (configurazioneTracciamento.getRegole()==null || 
  556.                                             configurazioneTracciamento.getRegole().isTracciamentoFileTraceResponseOutCompleteEnabled() ||
  557.                                             configurazioneTracciamento.isInitFileTraceByExternalPropertyPort())
  558.                                     || 
  559.                                     // outRequest
  560.                                     (configurazioneTracciamento.getRegole().isTracciamentoFileTraceRequestOutEnabledBloccante() || configurazioneTracciamento.getRegole().isTracciamentoFileTraceRequestOutEnabledNonBloccante())
  561.                                     ||
  562.                                     // outResponse
  563.                                     (configurazioneTracciamento.getRegole().isTracciamentoFileTraceResponseOutEnabledBloccante() || configurazioneTracciamento.getRegole().isTracciamentoFileTraceResponseOutEnabledNonBloccante())
  564.                                     ;
  565.                         }
  566.                         break;
  567.                     case OUT_REQUEST:
  568.                         fileTraceEnabledBloccante = configurazioneTracciamento.getRegole()!=null && configurazioneTracciamento.getRegole().isTracciamentoFileTraceRequestOutEnabledBloccante();
  569.                         fileTraceEnabledNonBloccante = configurazioneTracciamento.getRegole()!=null && configurazioneTracciamento.getRegole().isTracciamentoFileTraceRequestOutEnabledNonBloccante();
  570.                         
  571.                         // per ripulire le risorse
  572.                         if(this.openspcoopProperties.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase() && configurazioneTracciamento.isFileTraceEnabled()) {
  573.                             existsAnotherFiletraceTrackingPhase = 
  574.                                     // postOutResponse
  575.                                     (configurazioneTracciamento.getRegole()==null || 
  576.                                             configurazioneTracciamento.getRegole().isTracciamentoFileTraceResponseOutCompleteEnabled() ||
  577.                                             configurazioneTracciamento.isInitFileTraceByExternalPropertyPort())
  578.                                     || 
  579.                                     // outResponse
  580.                                     (configurazioneTracciamento.getRegole().isTracciamentoFileTraceResponseOutEnabledBloccante() || configurazioneTracciamento.getRegole().isTracciamentoFileTraceResponseOutEnabledNonBloccante())
  581.                                     ;
  582.                         }
  583.                         break;
  584.                     case OUT_RESPONSE:
  585.                         fileTraceEnabledBloccante = configurazioneTracciamento.getRegole()!=null && configurazioneTracciamento.getRegole().isTracciamentoFileTraceResponseOutEnabledBloccante();
  586.                         fileTraceEnabledNonBloccante = configurazioneTracciamento.getRegole()!=null && configurazioneTracciamento.getRegole().isTracciamentoFileTraceResponseOutEnabledNonBloccante();
  587.                         
  588.                         // per ripulire le risorse
  589.                         if(this.openspcoopProperties.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase() && configurazioneTracciamento.isFileTraceEnabled()) {
  590.                             existsAnotherFiletraceTrackingPhase = 
  591.                                     // postOutResponse
  592.                                     (configurazioneTracciamento.getRegole()==null || 
  593.                                             configurazioneTracciamento.getRegole().isTracciamentoFileTraceResponseOutCompleteEnabled() ||
  594.                                             configurazioneTracciamento.isInitFileTraceByExternalPropertyPort())
  595.                                     ;
  596.                         }
  597.                         break;
  598.                     case POST_OUT_RESPONSE:
  599.                         fileTraceEnabledBloccante = configurazioneTracciamento.getRegole()==null || 
  600.                             configurazioneTracciamento.getRegole().isTracciamentoFileTraceResponseOutCompleteEnabled() ||
  601.                             configurazioneTracciamento.isInitFileTraceByExternalPropertyPort();
  602.                         break;
  603.                     }
  604.                 }
  605.             }
  606.             
  607.         }catch (Exception e) {
  608.             this.logError(prefixIdTransazione+"errore durante la lettura della configurazione del tracciamento da effettuare: "+e.getMessage(),e);
  609.         }
  610.         
  611.         /* ---- Verifica Esito della Transazione per registrazione nello storico ----- */
  612.         
  613.         boolean exitTransactionAfterRateLimitingRemoveThreadNoTraceDB = false;
  614.         boolean noFileTrace = false;
  615.         if(!dbEnabledBloccante && !dbEnabledNonBloccante
  616.                 &&
  617.                 !fileTraceEnabledBloccante && !fileTraceEnabledNonBloccante
  618.             ) {
  619.             noFileTrace = true;
  620.             exitTransactionAfterRateLimitingRemoveThreadNoTraceDB = true;
  621.         }
  622.         else {
  623.             try{
  624.                 boolean forceDisableTransactionFilter = false;
  625.                 if(FaseTracciamento.OUT_RESPONSE.equals(this.fase) || FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)) {
  626.                     forceDisableTransactionFilter = this.existsTransactionFilter(info);
  627.                 }
  628.                 else if(FaseTracciamento.IN_REQUEST.equals(this.fase) || FaseTracciamento.OUT_REQUEST.equals(this.fase)){
  629.                     this.disableTransactionFilter(info);
  630.                 }
  631.                 
  632.                 if(forceDisableTransactionFilter) {
  633.                     if(this.debug){
  634.                         this.logDebug("["+idTransazione+"] Vengono registrati tutte le Transazioni indipendentemente dagli esiti poichè è stata precedentente effettuato un tracciamento nella fase "+getTransactionFilter(info)); 
  635.                     }
  636.                 }
  637.                 else {
  638.                     StringBuilder bf = new StringBuilder();
  639.                     String tipoFiltroEsiti = null;
  640.                     boolean filtroEsitiDB = false;
  641.                     boolean filtroEsitiFileTrace = false;
  642.                     List<String> esitiDaRegistrare = null;
  643.                     if(configurazioneTracciamento!=null) {
  644.                         esitiDaRegistrare = configurazioneTracciamento.getEsitiDaRegistrare(bf);
  645.                         tipoFiltroEsiti = configurazioneTracciamento.getTipoFiltroEsiti();
  646.                         filtroEsitiDB = configurazioneTracciamento.isFiltroEsitiDB();
  647.                         filtroEsitiFileTrace = configurazioneTracciamento.isFiltroEsitiFileTrace();
  648.                     }
  649.                     
  650.                     if(FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)) {
  651.                         if(filtroEsitiDB && this.existsTransactionFilterDB(info)) {
  652.                             filtroEsitiDB=false;
  653.                         }
  654.                         if(filtroEsitiFileTrace && this.existsTransactionFilterFileTrace(info)) {
  655.                             filtroEsitiFileTrace=false;
  656.                         }
  657.                     }
  658.                     
  659.                     if(esitiDaRegistrare==null || esitiDaRegistrare.isEmpty() || (!filtroEsitiDB && !filtroEsitiFileTrace)){
  660.                         esitiDaRegistrare = null;
  661.                         if(this.debug){
  662.                             this.logDebug("["+idTransazione+"] Vengono registrati tutte le Transazioni indipendentemente dagli esiti"); 
  663.                         }
  664.                     }
  665.                     else{
  666.                         if(this.debug){
  667.                             this.logDebug("["+idTransazione+"] ("+tipoFiltroEsiti+") Esiti delle Transazioni da registare: "+bf.toString()); 
  668.                         }
  669.                         if(esito!=null){
  670.                             
  671.                             boolean esitoDaRegistrare = ConfigurazioneTracciamentoUtils.isEsitoDaRegistrare(this.log, info.getProtocolFactory(), context, 
  672.                                     esitiDaRegistrare, esito);
  673.                             
  674.                             if(!esitoDaRegistrare){
  675.                                 String msg = prefixIdTransazione+"non salvata nello storico "+tipoFiltroEsiti+" come richiesto dalla configurazione del tracciamento: "+
  676.                                         ConfigurazioneTracciamentoUtils.getEsitoTransazionDetail(this.log, info.getProtocolFactory(),esito);
  677.                                 if(ConfigurazioneTracciamentoUtils.isEsitoOk(this.log, info.getProtocolFactory(),esito)) {
  678.                                     this.logWarn(msg);
  679.                                 }
  680.                                 else{
  681.                                     this.logError(msg);
  682.                                 }
  683.                                 
  684.                                 // BUG OP-825
  685.                                 // la gestione RateLimiting deve essere sempre fatta senno se si configurara di non registrare una transazione, poi si ha l'effetto che i contatori del Controllo del Traffico non vengono diminuiti.
  686.                                 if(filtroEsitiDB) {
  687.                                     exitTransactionAfterRateLimitingRemoveThreadNoTraceDB = true;
  688.                                 }
  689.                                 else if(FaseTracciamento.OUT_RESPONSE.equals(this.fase) &&
  690.                                     (dbEnabledBloccante || dbEnabledNonBloccante)) {
  691.                                     this.disableTransactionFilterDB(info);
  692.                                 }
  693.                                 
  694.                                 if(filtroEsitiFileTrace) {
  695.                                     noFileTrace = true;
  696.                                 }
  697.                                 else if(FaseTracciamento.OUT_RESPONSE.equals(this.fase) &&
  698.                                         (fileTraceEnabledBloccante || fileTraceEnabledNonBloccante)) {
  699.                                     this.disableTransactionFilterFileTrace(info);
  700.                                 }
  701.                             }
  702.                             else{
  703.                                 this.disableTransactionFilter(info);
  704.                             }
  705.                         }
  706.                         else{
  707.                             this.logError(prefixIdTransazione+"senza un esito");
  708.                         }
  709.                     }
  710.                 }
  711.             }catch (Exception e) {
  712.                 this.logError(prefixIdTransazione+"errore durante la lettura della configurazione del tracciamento da effettuare rispetto agli esiti: "+e.getMessage(),e);
  713.             }
  714.             
  715.             if(!exitTransactionAfterRateLimitingRemoveThreadNoTraceDB && !dbEnabledBloccante && !dbEnabledNonBloccante) {
  716.                 exitTransactionAfterRateLimitingRemoveThreadNoTraceDB = true;
  717.             }
  718.             if(!noFileTrace && !fileTraceEnabledBloccante && !fileTraceEnabledNonBloccante) {
  719.                 noFileTrace = true;
  720.             }
  721.             
  722.         }
  723.         
  724.         
  725.         
  726.         
  727.         

  729.             
  730.         /* ---- Recupero dati della transazione dal contesto ----- */
  731.         
  732.         Boolean controlloCongestioneMaxRequestThreadRegistrato = null;
  733.         if(FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase) && this.openspcoopProperties.isControlloTrafficoEnabled()){
  734.             Object objControlloCongestioneMaxRequestThreadRegistrato = context.getObject(CostantiControlloTraffico.PDD_CONTEXT_MAX_REQUEST_THREAD_REGISTRATO);
  735.             if(objControlloCongestioneMaxRequestThreadRegistrato!=null){
  736.                 controlloCongestioneMaxRequestThreadRegistrato = (Boolean) objControlloCongestioneMaxRequestThreadRegistrato;
  737.                 /**System.out.println("CHECK POST OUT ["+context.getTipoPorta().name()+"] controlloCongestioneMaxRequestViolated["+controlloCongestioneMaxRequestViolated+"] controllo["+PddInterceptorConfig.isControlloCongestioneTraceTransazioneMaxThreadsViolated()+"]");*/
  738.             }       
  739.         }
  740.         
  741.         // Check Transaction
  742.         if (transaction==null)
  743.             throw new HandlerException("Dati della transazione assenti");
  744.         if(FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)) {
  745.             transaction.setDeleted();
  746.         }


  749.         MisurazioniTransazione misurazioniTransazione = null;
  750.         Transazione transazioneDTO = null;
  751.         HandlerException fileTraceException = null;
  752.         try{
  753.             
  754.             RequestInfo requestInfo = null;
  755.             if(context!=null && context.containsKey(Costanti.REQUEST_INFO)){
  756.                 requestInfo = (RequestInfo) context.getObject(Costanti.REQUEST_INFO);
  757.             }
  758.             
  759.             IDSoggetto idDominio = this.openspcoopProperties.getIdentitaPortaDefault(info.getProtocolFactory().getProtocol(), requestInfo); 
  760.             if(info.getProtocollo()!=null && info.getProtocollo().getDominio()!=null && !info.getProtocollo().getDominio().equals(idDominio)){
  761.                 idDominio = info.getProtocollo().getDominio();
  762.             }
  763.             else if(requestInfo!=null &&
  764.                 requestInfo.getIdentitaPdD()!=null && !requestInfo.getIdentitaPdD().equals(idDominio)){
  765.                 idDominio = requestInfo.getIdentitaPdD();
  766.             }
  767.     
  768.             String modulo = "Tracciamento-"+this.fase;
  769.     
  770.             ExceptionSerialzerFileSystem exceptionSerializerFileSystem = new ExceptionSerialzerFileSystem(this.log);
  771.     
  772.             
  773.             // ### Lettura dati Transazione ###
  774.             
  775.             boolean pddStateless = true;
  776.             TransazioneUtilities transazioneUtilities = null;
  777.             HandlerException he = null;
  778.             long timeStart = -1;
  779.             try{
  780.                 if(exitTransactionAfterRateLimitingRemoveThreadNoTraceDB && noFileTrace) {
  781.                     if(FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase) && this.openspcoopProperties.isControlloTrafficoEnabled()){
  782.                         misurazioniTransazione = TransazioneUtilities.fillMisurazioniTransazione(info, this.fase, transaction, esito, transazioneDTO);
  783.                     }
  784.                     return; // entro nel finally e se sono post out rimuovo il thread per il controllo del traffico
  785.                 }
  786.                 
  787.                 if(times!=null) {
  788.                     timeStart = DateManager.getTimeMillis();
  789.                 }
  790.                 
  791.                 // Stateless
  792. /**             if ( (context.getIntegrazione()==null) ||
  793. //                      (context.getIntegrazione().isGestioneStateless()==null) ||
  794. //                      (context.getIntegrazione().isGestioneStateless()==false) 
  795. //                      ){
  796. //                  pddStateless = false;
  797. //              }*/
  798.                 // Cambio l'approccio per poter simulare anche gli errori nei diagnostici dove possibile
  799.                 // Tanto tutte le comunicazioni sono stateless a meno che non vengano tramutate in stateful
  800.                 if ( info.getIntegrazione()!=null && 
  801.                         info.getIntegrazione().isGestioneStateless()!=null &&
  802.                                 !info.getIntegrazione().isGestioneStateless().booleanValue()){
  803.                     pddStateless = false;
  804.                 }
  805.                 
  806.                 /* ---- Salvo informazioni sulla transazioni nell'oggetto transazioniDTO ----- */
  807.                 transazioneUtilities = new TransazioneUtilities(this.log, this.openspcoopProperties,
  808.                         this.transazioniRegistrazioneTracceHeaderRawEnabled,
  809.                         this.transazioniRegistrazioneTracceDigestEnabled,
  810.                         this.transazioniRegistrazioneTracceProtocolPropertiesEnabled,
  811.                         configurazioneTracciamento!=null ? configurazioneTracciamento.getInformazioniSalvareTransazioni() : null);
  812.                 transazioneDTO = transazioneUtilities.fillTransaction(info, transaction, idDominio,
  813.                         ( (times!=null && this.openspcoopProperties.isTransazioniRegistrazioneSlowLogBuildTransactionDetails()) ? times : null),
  814.                         this.fase, 
  815.                         esito, esitoContext, 
  816.                         info.getTransazioneDaAggiornare()); // NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  817.                 if(FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase) && this.openspcoopProperties.isControlloTrafficoEnabled()){
  818.                     misurazioniTransazione = TransazioneUtilities.fillMisurazioniTransazione(info, this.fase, transaction, esito, transazioneDTO);
  819.                 }
  820.                 if(FaseTracciamento.OUT_RESPONSE.equals(this.fase)) {
  821.                     info.setTransazioneDaAggiornare(transazioneDTO);
  822.                 }
  823.     
  824.             }catch (Throwable e) {
  825.                 try{
  826.                     if(FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)) {
  827.                         exceptionSerializerFileSystem.registrazioneFileSystemDiagnosticiTracceDumpEmessiPdD(transaction, idTransazione, null,
  828.                                 true, true, true, true);
  829.                     }
  830.                 } catch (Exception eClose) {
  831.                     // ignore
  832.                 }
  833.                 // Effettuo il log anche nel core per evitare che un eventuale filtro a OFF sul core della PdD eviti la scrittura di questi errori
  834.                 String msg = "Errore durante la scrittura della transazione sul database (Lettura dati Transazione): " + e.getLocalizedMessage();
  835.                 this.logError("["+idTransazione+"] "+msg,e);
  836.                 he = new HandlerException(msg,e);
  837.             }
  838.             finally {   

  840.                 if(times!=null) {
  841.                     long timeEnd =  DateManager.getTimeMillis();
  842.                     long timeProcess = timeEnd-timeStart;
  843.                     times.fillTransaction = timeProcess;
  844.                 }
  845.                 
  846.                 // ### Gestione Controllo Congestione ###
  847.                 // Nota: il motivo del perchè viene effettuato qua la "remove"
  848.                 //       risiede nel fatto che la risposta al client è già stata data
  849.                 //       però il "thread occupato" dal client non è ancora stato liberato per una nuova richiesta
  850.                 //       Se la remove viene messa nel finally del try-catch sottostante prima della remove si "paga" 
  851.                 //       i tempi di attesa dell'inserimento della transazione sul database
  852.                 if(FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase) && this.openspcoopProperties.isControlloTrafficoEnabled()){
  853.                     
  854.                     try {
  855.                         if(times!=null) {
  856.                             timeStart = DateManager.getTimeMillis();
  857.                         }
  858.                         PostOutResponseHandlerGestioneControlloTraffico outHandler = new PostOutResponseHandlerGestioneControlloTraffico();
  859.                         outHandler.process(controlloCongestioneMaxRequestThreadRegistrato, this.log, idTransazione, misurazioniTransazione, info,
  860.                                 ( (times!=null && this.openspcoopProperties.isTransazioniRegistrazioneSlowLogRateLimitingDetails()) ? times : null));
  861.                     }catch (Throwable e) {
  862.                         this.logError("["+idTransazione+"] Errore durante la registrazione di terminazione del thread: "+e.getMessage(),e);
  863.                     }finally {
  864.                         if(times!=null) {
  865.                             long timeEnd =  DateManager.getTimeMillis();
  866.                             long timeProcess = timeEnd-timeStart;
  867.                             times.controlloTraffico = timeProcess;
  868.                         }
  869.                     }
  870.                 }
  871.                 
  872.                 // ### FileTrace ###
  873.                 if((fileTraceEnabledBloccante || fileTraceEnabledNonBloccante) && !noFileTrace) {
  874.                     
  875.                     InformazioniToken informazioniToken = null;
  876.                     InformazioniAttributi informazioniAttributi = null;
  877.                     InformazioniNegoziazioneToken informazioniNegoziazioneToken = null;
  878.                     SecurityToken securityToken = null;
  879.                     if(transaction!=null) {
  880.                         informazioniToken = transaction.getInformazioniToken();
  881.                         informazioniNegoziazioneToken = transaction.getInformazioniNegoziazioneToken();
  882.                     }
  883.                     if(context!=null) {
  884.                         Object oInformazioniAttributiNormalizzati = context.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_ATTRIBUTI_INFORMAZIONI_NORMALIZZATE);
  885.                         if(oInformazioniAttributiNormalizzati instanceof InformazioniAttributi) {
  886.                             informazioniAttributi = (InformazioniAttributi) oInformazioniAttributiNormalizzati;
  887.                         }
  888.                         securityToken = SecurityTokenUtilities.readSecurityToken(context);
  889.                     }
  890.                     
  891.                     fileTraceException = logWithFileTrace(fileTraceConfig, fileTraceConfigGlobal,
  892.                             times,
  893.                             transazioneDTO, transaction, esito,
  894.                             informazioniToken,
  895.                             informazioniAttributi,
  896.                             informazioniNegoziazioneToken,
  897.                             securityToken,
  898.                             info,
  899.                             headerInUscita,
  900.                             requestInfo,
  901.                             idTransazione,
  902.                             fileTraceEnabledBloccante,
  903.                             msgdiagErrore,
  904.                             existsAnotherFiletraceTrackingPhase); // anche qua vi e' un try catch con Throwable
  905.                 }
  906.                 
  907.             }
  908.             
  909.             if(he!=null) {
  910.                 throw he;
  911.             }
  912.             else if(exitTransactionAfterRateLimitingRemoveThreadNoTraceDB){
  913.                 // La risorsa viene rilasciata nel finally
  914.                 /**this.releaseResources(transaction, idTransazione, context);*/
  915.                 
  916.                 // se non devo tracciare su db ma ho avuto un errore su file trace devo registrarlo
  917.                 if(fileTraceException!=null) {
  918.                     throw fileTraceException;
  919.                 }
  920.                 
  921.                 return;
  922.             }
  923.             
  924.             
  925.             
  926.             // Il controllo stateful è stato spostato sotto il blocco soprastante, per assicurare la gestione del traffico (decremento dei contatori)
  927.             
  928.             // NOTA: se l'integrazione e' null o l'indicazione se la gestione stateless e' null, significa che la PdD non e' ancora riuscita
  929.             // a capire che tipo di gestione deve adottare. Queste transazioni devono essere sempre registrate perche' riguardano cooperazioni andate in errore all'inizio,
  930.             // es. Porta Delegata non esistente, busta malformata....
  931.             if(info.getIntegrazione()!=null && 
  932.                     info.getIntegrazione().isGestioneStateless()!=null &&
  933.                     !info.getIntegrazione().isGestioneStateless().booleanValue() &&
  934.                 !this.openspcoopProperties.isTransazioniStatefulEnabled()){
  935.                 /**if(this.debug)*/
  936.                 this.logError("["+idTransazione+"] Transazione non registrata, gestione stateful non abilitata");
  937.                 // NOTA: Da fare thread che ripulisce header di trasporto o dump messaggi non associati a transazioni.
  938.                 // La risorsa viene rilasciata nel finally
  939.                 /**this._releaseResources(transaction, idTransazione, context);*/
  940.                 
  941.                 // se non devo tracciare su db ma ho avuto un errore su file trace devo registrarlo
  942.                 if(fileTraceException!=null) {
  943.                     throw fileTraceException;
  944.                 }
  945.                 
  946.                 return;
  947.             }
  948.             
  949.             
  950.             
  951.             
  952.             
  953.     
  954.             
  955.             
  956.             // ### Gestione Transazione ###
  957.     
  958.             boolean autoCommit = true;
  959.             DBTransazioniManager dbManager = null;
  960.             Resource resource = null;
  961.             Connection connection = null;
  962.             boolean errore = false;
  963.             boolean registraTracciaRichiesta = (FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase) && info.getTransazioneDaAggiornare()==null)
  964.                     ||
  965.                     (FaseTracciamento.OUT_RESPONSE.equals(this.fase));
  966.             boolean registraTracciaRichiestaInfoTransazione = false; 
  967.             boolean registraTracciaRisposta = (FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase) && info.getTransazioneDaAggiornare()==null)
  968.                     ||
  969.                     (FaseTracciamento.OUT_RESPONSE.equals(this.fase));
  970.             boolean registraTracciaRispostaInfoTransazione = false; 
  971.             boolean registrazioneMessaggiDiagnostici = true;
  972.             boolean registrazioneDumpMessaggi = true;
  973.             boolean insertTransazione = false;
  974.             try {
  975.                 

  977.                     
  978.                 /* ---- Recupero informazioni sulla modalita' di salvataggio delle tracce ----- */
  979.     
  980.                 String informazioneTracciaRichiestaDaSalvare = null;
  981.                 String informazioneTracciaRispostaDaSalvare = null;
  982.                 HashMap<DiagnosticColumnType, String> informazioniDiagnosticiDaSalvare = null;
  983.                 try {
  984.                     if(times!=null) {
  985.                         timeStart = DateManager.getTimeMillis();
  986.                     }
  987.                     
  988.                     // TRACCIA RICHIESTA
  989.                     if( 
  990.                             registraTracciaRichiesta
  991.                             && 
  992.                             this.salvataggioTracceManager!=null) {
  993.                         
  994.                         registraTracciaRichiestaInfoTransazione = true;
  995.                         
  996.                         StatoSalvataggioTracce statoTracciaRichiesta =  
  997.                                 this.salvataggioTracceManager.getInformazioniSalvataggioTracciaRichiesta(this.log, info, transaction, transazioneDTO, pddStateless);
  998.                         if(statoTracciaRichiesta!=null) {
  999.                             registraTracciaRichiesta = (!statoTracciaRichiesta.isCompresso());
  1000.                             informazioneTracciaRichiestaDaSalvare = statoTracciaRichiesta.getInformazioneCompressa();
  1001.                         }
  1002.                         if(this.debug){
  1003.                             this.logDebug("["+idTransazione+"] Emissione traccia richiesta: "+registraTracciaRichiesta);
  1004.                             if(statoTracciaRichiesta!=null) {
  1005.                                 this.logDebug("["+idTransazione+"] Informazioni Salvataggio traccia richiesta (compresso:"+statoTracciaRichiesta.isCompresso()+
  1006.                                         " errore:"+statoTracciaRichiesta.isErrore()+"): "+statoTracciaRichiesta.getInformazione());
  1007.                             }
  1008.                         }
  1009.                         else{
  1010.                             if(statoTracciaRichiesta!=null && statoTracciaRichiesta.isErrore()){
  1011.                                     this.logWarn("["+idTransazione+"] Informazioni Salvataggio traccia richiesta in errore: "+statoTracciaRichiesta.getInformazione());
  1012.                             }
  1013.                         }
  1014.                     }
  1015.                     
  1016.                     // TRACCIA RISPOSTA
  1017.                     if( 
  1018.                             registraTracciaRisposta
  1019.                             && 
  1020.                             this.salvataggioTracceManager!=null) {
  1021.                         
  1022.                         registraTracciaRispostaInfoTransazione = true;
  1023.                         
  1024.                         StatoSalvataggioTracce statoTracciaRisposta =  
  1025.                                 this.salvataggioTracceManager.getInformazioniSalvataggioTracciaRisposta(this.log, info, transaction, transazioneDTO, pddStateless);
  1026.                         if(statoTracciaRisposta!=null) {
  1027.                             registraTracciaRisposta = (!statoTracciaRisposta.isCompresso());
  1028.                             informazioneTracciaRispostaDaSalvare = statoTracciaRisposta.getInformazioneCompressa();
  1029.                         }
  1030.                         if(this.debug){
  1031.                             this.logDebug("["+idTransazione+"] Emissione traccia risposta: "+registraTracciaRisposta);
  1032.                             if(statoTracciaRisposta!=null) {
  1033.                                 this.logDebug("["+idTransazione+"] Informazioni Salvataggio traccia risposta (compresso:"+statoTracciaRisposta.isCompresso()+
  1034.                                         " errore:"+statoTracciaRisposta.isErrore()+"): "+statoTracciaRisposta.getInformazione());
  1035.                             }
  1036.                         }
  1037.                         else{
  1038.                             if(statoTracciaRisposta!=null && statoTracciaRisposta.isErrore()){
  1039.                                     this.logWarn("["+idTransazione+"] Informazioni Salvataggio traccia risposta in errore: "+statoTracciaRisposta.getInformazione());
  1040.                             }
  1041.                         }
  1042.                     }
  1043.         
  1044.                     // MESSAGGI DIAGNOSTICI
  1045.                     if(this.salvataggioDiagnosticiManager!=null) {
  1046.                         StatoSalvataggioDiagnostici statoDiagnostici =  
  1047.                                 this.salvataggioDiagnosticiManager.getInformazioniSalvataggioDiagnostici(this.log, info, transaction, transazioneDTO, pddStateless);
  1048.                         if(statoDiagnostici!=null) {
  1049.                             registrazioneMessaggiDiagnostici = (!statoDiagnostici.isCompresso());
  1050.                             informazioniDiagnosticiDaSalvare = statoDiagnostici.getInformazioneCompressa();
  1051.                         }
  1052.                         if(this.debug){
  1053.                             this.logDebug("["+idTransazione+"] Emissione diagnostici: "+registrazioneMessaggiDiagnostici);
  1054.                             if(statoDiagnostici!=null) {
  1055.                                 this.logDebug("["+idTransazione+"] Informazioni Salvataggio diagnostici (compresso:"+statoDiagnostici.isCompresso()+
  1056.                                         " errore :"+statoDiagnostici.isErrore()+"): "+statoDiagnostici.getInformazione());
  1057.                             }
  1058.                         }
  1059.                         else{
  1060.                             if(statoDiagnostici!=null && statoDiagnostici.isErrore()){
  1061.                                     this.logWarn("["+idTransazione+"] Informazioni Salvataggio diagnostici in errore: "+statoDiagnostici.getInformazione());
  1062.                             }
  1063.                         }
  1064.                         if(registrazioneMessaggiDiagnostici && !FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)) {
  1065.                             registrazioneMessaggiDiagnostici = false; // con salvataggioDiagnosticiManager si scrivono nella tabella msgdiagnostici solo in fondo
  1066.                         }
  1067.                     }
  1068.                 }finally {
  1069.                     if(times!=null) {
  1070.                         long timeEnd =  DateManager.getTimeMillis();
  1071.                         long timeProcess = timeEnd-timeStart;
  1072.                         times.processTransactionInfo = timeProcess;
  1073.                     }
  1074.                 }
  1075.                 
  1076.                 // IMPOSTO INFORMAZIONI IN TRANSAZIONE DTO
  1077.                 
  1078.                 // ** dati tracce **
  1079.                 transazioneDTO.setTracciaRichiesta(informazioneTracciaRichiestaDaSalvare);
  1080.                 transazioneDTO.setTracciaRisposta(informazioneTracciaRispostaDaSalvare);
  1081.                 
  1082.                 // ** dati diagnostica **
  1083.                 if(informazioniDiagnosticiDaSalvare!=null){
  1084.                     transazioneDTO.setDiagnostici(informazioniDiagnosticiDaSalvare.get(DiagnosticColumnType.META_INF));
  1085.                     transazioneDTO.setDiagnosticiList1(informazioniDiagnosticiDaSalvare.get(DiagnosticColumnType.LIST1));
  1086.                     transazioneDTO.setDiagnosticiList2(informazioniDiagnosticiDaSalvare.get(DiagnosticColumnType.LIST2));
  1087.                     transazioneDTO.setDiagnosticiListExt(informazioniDiagnosticiDaSalvare.get(DiagnosticColumnType.LIST_EXT));
  1088.                     transazioneDTO.setDiagnosticiExt(informazioniDiagnosticiDaSalvare.get(DiagnosticColumnType.EXT));
  1089.                 }
  1090.     
  1091.                 
  1092.                 // DUMP
  1093.                 
  1094.                 boolean registrazioneContenuti = false;
  1095.                 for(int i=0; i<transaction.sizeMessaggi(); i++){
  1096.                     Messaggio messaggio = transaction.getMessaggio(i);
  1097.                     if(!messaggio.isStored()) {
  1098.                         registrazioneContenuti=true;
  1099.                         break;
  1100.                     }
  1101.                 }
  1102.                 
  1103.                 // CONTENUTI
  1104.                 boolean registrazioneRisorse = transaction.getTransactionServiceLibrary()!=null || (transaction.getRisorse()!=null && !transaction.getRisorse().isEmpty()); /**transaction.sizeMessaggi()>0;*/
  1105.                 
  1106.     
  1107.                 // AUTO-COMMIT
  1108.                 if(registraTracciaRichiesta || registraTracciaRisposta || registrazioneMessaggiDiagnostici ||  registrazioneContenuti || registrazioneRisorse){
  1109.                     autoCommit = false; // devo registrare piu' informazioni oltre alla transazione
  1110.                 }
  1111.                 if(this.debug)
  1112.                     this.logSqlDebug("["+idTransazione+"] AutoCommit: "+this.debug);
  1113.     
  1114.     
  1115.                 
  1116.                 
  1117.                 
  1118.                 
  1119.                 
  1120.                 // Dopo aver assegnato tutti i valori all'oggetto transazione, in modo da poterlo salvare su filesystem
  1121.                 if(
  1122.                         (FaseTracciamento.OUT_REQUEST.equals(this.fase) && this.openspcoopProperties.isTransazioniTracciamentoDBOutRequestThrowRequestException() )
  1123.                         ||
  1124.                         (FaseTracciamento.OUT_RESPONSE.equals(this.fase) && this.openspcoopProperties.isTransazioniTracciamentoDBOutResponseThrowRequestException() )
  1125.                         ||
  1126.                         (FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase) && 
  1127.                                 (
  1128.                                         this.openspcoopProperties.isTransazioniTracciamentoDBPostOutResponseThrowRequestException() 
  1129.                                         ||
  1130.                                         this.openspcoopProperties.isTransazioniTracciamentoDBPostOutResponseThrowResponseException()
  1131.                                 )
  1132.                         )
  1133.                     ) {
  1134.                     throwTrackingExceptionIfExists(info);
  1135.                 }
  1136.                 
  1137.                 
  1138.                 
  1139.                 
  1140.     
  1141.     
  1142.     
  1143.                 /* ---- Connection/Service Manager ----- */
  1144.     
  1145.                 if(this.debug)
  1146.                     this.logSqlDebug("["+idTransazione+"] recupero jdbcServiceManager in corso ...");

  1148.                 
  1149.                 // Ottiene la connessione al db
  1150.                 try {
  1151.                     if(times!=null) {
  1152.                         timeStart = DateManager.getTimeMillis();
  1153.                     }
  1154.                     dbManager = DBTransazioniManager.getInstance();
  1155.                     resource = dbManager.getResource(idDominio, modulo, idTransazione);
  1156.                 }finally {
  1157.                     if(times!=null) {
  1158.                         long timeEnd =  DateManager.getTimeMillis();
  1159.                         long timeProcess = timeEnd-timeStart;
  1160.                         times.getConnection = timeProcess;
  1161.                     }
  1162.                 }
  1163.                 if(resource==null){
  1164.                     throw new CoreException("Risorsa al database non disponibile");
  1165.                 }
  1166.                 connection = (Connection) resource.getResource();
  1167.                 if(connection == null)
  1168.                     throw new CoreException("Connessione non disponibile"); 

  1170.                 if(!autoCommit){
  1171.                     connection.setAutoCommit(false);
  1172.                 }
  1173.                 org.openspcoop2.core.transazioni.dao.jdbc.JDBCServiceManager jdbcServiceManager =
  1174.                         (org.openspcoop2.core.transazioni.dao.jdbc.JDBCServiceManager) 
  1175.                         this.daoFactory.getServiceManager(org.openspcoop2.core.transazioni.utils.ProjectInfo.getInstance(), 
  1176.                                 connection, autoCommit,
  1177.                                 this.daoFactoryServiceManagerPropertiesTransazioni, this.daoFactoryLoggerTransazioni);
  1178.                 jdbcServiceManager.getJdbcProperties().setShowSql(this.debug);
  1179.                 ITransazioneService transazioneService = jdbcServiceManager.getTransazioneService();
  1180.                 if(this.debug)
  1181.                     this.logSqlDebug("["+idTransazione+"] recupero jdbcServiceManager effettuato");
  1182.     
  1183.                 /**System.out.println("\n\n\n****** ["+this.fase+"]["+transazioneDTO.getIdTransazione()+"] (autoCommit:"+autoCommit+") ["+transazioneDTO.getPddRuolo()+"]["+transazioneDTO.getPddCodice()+"]["+transazioneDTO.getNomeServizio()+"] *******");*/
  1184.                 
  1185.     

  1187.     
  1188.                 /* ---- Inserimento dati transazione ----- */
  1189.     
  1190.                 // Inserisco transazione
  1191.                 if(this.debug)
  1192.                     this.logDebug("["+idTransazione+"] inserimento transazione in corso ...");
  1193.                 
  1194.                 try {
  1195.                     if(times!=null) {
  1196.                         timeStart = DateManager.getTimeMillis();
  1197.                     }
  1198.                     insertTransazione = registraTransazione(transazioneDTO,
  1199.                             transazioneService, info,
  1200.                             autoCommit, registraTracciaRichiestaInfoTransazione, registraTracciaRispostaInfoTransazione);
  1201.                 }finally {
  1202.                     if(times!=null) {
  1203.                         long timeEnd =  DateManager.getTimeMillis();
  1204.                         long timeProcess = timeEnd-timeStart;
  1205.                         times.insertTransaction = timeProcess;
  1206.                     }
  1207.                 }
  1208.                 if(this.debug)
  1209.                     this.logDebug("["+idTransazione+"] inserita transazione");
  1210.     

  1212.     
  1213.     
  1214.     
  1215.                 /* ---- Inserimento dati tracce ----- */
  1216.                 
  1217.                 List<Traccia> tracceSalvate = new ArrayList<>();
  1218.                 try {
  1219.                     timeStart = -1;
  1220.                     
  1221.                     if( 
  1222.                             !FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase) 
  1223.                             &&
  1224.                             (
  1225.                                     (registraTracciaRichiesta && transaction.getTracciaRichiesta()!=null)
  1226.                                     ||
  1227.                                     (registraTracciaRisposta && transaction.getTracciaRisposta()!=null)
  1228.                             )
  1229.                         ){
  1230.                         initTracciamento(this.tipoDatabaseRuntime, this.usePdDConnection);
  1231.                     }
  1232.                     
  1233.                     if( registraTracciaRichiesta && transaction.getTracciaRichiesta()!=null){
  1234.                         if(times!=null) {
  1235.                             timeStart = DateManager.getTimeMillis();
  1236.                         }
  1237.                         if(transaction.getTracciaRichiesta().isStored()) {
  1238.                             if(this.debug)
  1239.                                 this.logDebug("["+idTransazione+"] registrazione traccia richiesta skipped");
  1240.                         }
  1241.                         else {
  1242.                             if(this.debug)
  1243.                                 this.logDebug("["+idTransazione+"] registrazione traccia richiesta...");
  1244.                             /**System.out.println("["+this.fase+"]["+transazioneDTO.getIdTransazione()+"]["+transazioneDTO.getPddRuolo()+"]["+transazioneDTO.getPddCodice()+"]["+transazioneDTO.getNomeServizio()+"] INSERT TRACCIA RICHIESTA");*/
  1245.                             this.tracciamentoOpenSPCoopAppender.log(connection, transaction.getTracciaRichiesta());
  1246.                             if(this.debug)
  1247.                                 this.logDebug("["+idTransazione+"] registrazione traccia richiesta completata");
  1248.                             if(autoCommit) {
  1249.                                 transaction.getTracciaRichiesta().setStored(true);
  1250.                             }
  1251.                             else {
  1252.                                 tracceSalvate.add(transaction.getTracciaRichiesta());
  1253.                             }
  1254.                         }
  1255.                     }   
  1256.                     if( registraTracciaRisposta && transaction.getTracciaRisposta()!=null){
  1257.                         if(times!=null && timeStart==-1) {
  1258.                             timeStart = DateManager.getTimeMillis();
  1259.                         }
  1260.                         if(transaction.getTracciaRisposta().isStored()) {
  1261.                             if(this.debug)
  1262.                                 this.logDebug("["+idTransazione+"] registrazione traccia richiesta skipped");
  1263.                         }
  1264.                         else {
  1265.                             if(this.debug)
  1266.                                 this.logDebug("["+idTransazione+"] registrazione traccia risposta...");
  1267.                             /**System.out.println("["+this.fase+"]["+transazioneDTO.getIdTransazione()+"]["+transazioneDTO.getPddRuolo()+"]["+transazioneDTO.getPddCodice()+"]["+transazioneDTO.getNomeServizio()+"] INSERT TRACCIA RISPOSTA");*/
  1268.                             this.tracciamentoOpenSPCoopAppender.log(connection, transaction.getTracciaRisposta());
  1269.                             if(this.debug)
  1270.                                 this.logDebug("["+idTransazione+"] registrazione traccia risposta completata");
  1271.                             if(autoCommit) {
  1272.                                 transaction.getTracciaRisposta().setStored(true);
  1273.                             }
  1274.                             else {
  1275.                                 tracceSalvate.add(transaction.getTracciaRisposta());
  1276.                             }
  1277.                         }
  1278.                     }   
  1279.                 }finally {
  1280.                     if(times!=null && timeStart>0) {
  1281.                         long timeEnd =  DateManager.getTimeMillis();
  1282.                         long timeProcess = timeEnd-timeStart;
  1283.                         times.insertTrace = timeProcess;
  1284.                     }
  1285.                 }
  1286.     
  1287.     

  1289.     
  1290.     
  1291.                 /* ---- Inserimento messaggi diagnostici ----- */
  1292.                 
  1293.                 List<MsgDiagnostico> diagnosticiSalvati = new ArrayList<>();
  1294.                 try {
  1295.                     timeStart = -1;
  1296.                     if(registrazioneMessaggiDiagnostici){
  1297.                         
  1298.                         if(!FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)) {
  1299.                             initDiagnostica(this.tipoDatabaseRuntime, this.usePdDConnection);
  1300.                         }
  1301.                         
  1302.                         if(times!=null && transaction!=null && transaction.sizeMsgDiagnostici()>0) {
  1303.                             timeStart = DateManager.getTimeMillis();
  1304.                         }
  1305.                         for(int i=0; i<transaction.sizeMsgDiagnostici(); i++){
  1306.                             MsgDiagnostico msgDiagnostico = transaction.getMsgDiagnostico(i);
  1307.                             if(msgDiagnostico.isStored()) {
  1308.                                 if(this.debug)
  1309.                                     this.logDebug("["+idTransazione+"] registrazione diagnostico con codice ["+msgDiagnostico.getCodice()+"] skipped");
  1310.                                 continue;
  1311.                             }
  1312.                             if(msgDiagnostico.getIdSoggetto()==null){
  1313.                                 msgDiagnostico.setIdSoggetto(idDominio);
  1314.                             }
  1315.                             if(this.debug)
  1316.                                 this.logDebug("["+idTransazione+"] registrazione diagnostico con codice ["+msgDiagnostico.getCodice()+"] ...");
  1317.                             /**System.out.println("["+this.fase+"]["+transazioneDTO.getIdTransazione()+"]["+transazioneDTO.getPddRuolo()+"]["+transazioneDTO.getPddCodice()+"]["+transazioneDTO.getNomeServizio()+"] INSERT DIAG ["+msgDiagnostico.getCodice()+"]");*/
  1318.                             this.msgDiagnosticiOpenSPCoopAppender.log(connection,msgDiagnostico);
  1319.                             if(this.debug)
  1320.                                 this.logDebug("["+idTransazione+"] registrazione diagnostico con codice ["+msgDiagnostico.getCodice()+"] completata");
  1321.                             if(autoCommit) {
  1322.                                 msgDiagnostico.setStored(true);
  1323.                             }
  1324.                             else {
  1325.                                 diagnosticiSalvati.add(msgDiagnostico);
  1326.                             }
  1327.                         }
  1328.                     }
  1329.                 }finally {
  1330.                     if(times!=null && timeStart>0) {
  1331.                         long timeEnd =  DateManager.getTimeMillis();
  1332.                         long timeProcess = timeEnd-timeStart;
  1333.                         times.insertDiagnostics = timeProcess;
  1334.                     }
  1335.                 }
  1336.     
  1337.                 
  1338.                 

  1340.                 
  1341.                 
  1342.                 
  1343.                 /* ---- Inserimento dump ----- */
  1344.                 
  1345.                 List<Messaggio> messaggiSalvati = new ArrayList<>();
  1346.                 try {
  1347.                     timeStart = -1;
  1348.                     if(times!=null && transaction!=null && transaction.sizeMessaggi()>0) {
  1349.                         timeStart = DateManager.getTimeMillis();
  1350.                     }
  1351.                     for(int i=0; i<transaction.sizeMessaggi(); i++){
  1352.                         Messaggio messaggio = transaction.getMessaggio(i);
  1353.                         if(messaggio.isStored()) {
  1354.                             if(this.debug)
  1355.                                 this.logDebug("["+idTransazione+"] registrazione messaggio di tipo ["+messaggio.getTipoMessaggio()+"] skipped");
  1356.                             continue;
  1357.                         }
  1358.                         try {
  1359.                             if(!FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)) {
  1360.                                 initDump(this.tipoDatabaseRuntime, this.usePdDConnection);
  1361.                             }                           
  1362.                             
  1363.                             if(messaggio.getProtocollo()==null) {
  1364.                                 messaggio.setProtocollo(transazioneDTO.getProtocollo());
  1365.                             }
  1366.                             if(messaggio.getDominio()==null) {
  1367.                                 messaggio.setDominio(idDominio);
  1368.                             }
  1369.                             if(messaggio.getTipoPdD()==null) {
  1370.                                 messaggio.setTipoPdD(info.getTipoPorta());
  1371.                             }
  1372.                             if(messaggio.getIdFunzione()==null) {
  1373.                                 messaggio.setIdFunzione(modulo);
  1374.                             }
  1375.                             if(messaggio.getIdBusta()==null &&
  1376.                                 info.getProtocollo()!=null) {
  1377.                                 messaggio.setIdBusta(info.getProtocollo().getIdRichiesta());
  1378.                             }
  1379.                             if(messaggio.getFruitore()==null &&
  1380.                                 info.getProtocollo()!=null) {
  1381.                                 messaggio.setFruitore(info.getProtocollo().getFruitore());
  1382.                             }
  1383.                             if(messaggio.getServizio()==null &&
  1384.                                 info.getProtocollo()!=null) {
  1385.                                 IDServizio idServizio = IDServizioFactory.getInstance().
  1386.                                         getIDServizioFromValuesWithoutCheck(info.getProtocollo().getTipoServizio(), 
  1387.                                                 info.getProtocollo().getServizio(), 
  1388.                                                 info.getProtocollo().getErogatore()!=null ? info.getProtocollo().getErogatore().getTipo() : null, 
  1389.                                                 info.getProtocollo().getErogatore()!=null ? info.getProtocollo().getErogatore().getNome() : null,
  1390.                                                 info.getProtocollo().getVersioneServizio()!=null ? info.getProtocollo().getVersioneServizio() : -1);
  1391.                                 messaggio.setServizio(idServizio);
  1392.                             }
  1393.                             if(this.debug)
  1394.                                 this.logDebug("["+idTransazione+"] registrazione messaggio di tipo ["+messaggio.getTipoMessaggio()+"] ...");
  1395.                             /**System.out.println("["+this.fase+"]["+transazioneDTO.getIdTransazione()+"]["+transazioneDTO.getPddRuolo()+"]["+transazioneDTO.getPddCodice()+"]["+transazioneDTO.getNomeServizio()+"] INSERT MESSAGGIO ["+messaggio.getTipoMessaggio()+"]");*/
  1396.                             this.dumpOpenSPCoopAppender.dump(connection,messaggio,this.transazioniRegistrazioneDumpHeadersCompactEnabled);
  1397.                             if(this.debug)
  1398.                                 this.logDebug("["+idTransazione+"] registrazione messaggio di tipo ["+messaggio.getTipoMessaggio()+"] completata");
  1399.                             if(autoCommit) {
  1400.                                 messaggio.setStored(true);
  1401.                             }
  1402.                             else {
  1403.                                 messaggiSalvati.add(messaggio);
  1404.                             }
  1405.                         }finally {
  1406.                             try {
  1407.                                 if(messaggio.getBody()!=null) {
  1408.                                     messaggio.getBody().unlock();
  1409.                                     messaggio.getBody().clearResources();
  1410.                                 }
  1411.                             }catch(Exception t){
  1412.                                 this.logError("["+idTransazione+"] errore durante il rilascio delle risorse del messaggio: "+t.getMessage(),t);
  1413.                             }
  1414.                         }
  1415.                     }
  1416.                 }finally {
  1417.                     if(times!=null && timeStart>0) {
  1418.                         long timeEnd =  DateManager.getTimeMillis();
  1419.                         long timeProcess = timeEnd-timeStart;
  1420.                         times.insertContents = timeProcess;
  1421.                     }
  1422.                 }

  1424.                 
  1425.                 
  1426.                 
  1427.                 /* ---- Inserimento risorse contenuti (library personalizzata) ----- */
  1428.                 
  1429.                 if(registrazioneRisorse){
  1430.                     /**System.out.println("["+this.fase+"]["+transazioneDTO.getIdTransazione()+"]["+transazioneDTO.getPddRuolo()+"]["+transazioneDTO.getPddCodice()+"]["+transazioneDTO.getNomeServizio()+"] RISORSE");*/
  1431.                     try {
  1432.                         if(times!=null) {
  1433.                             timeStart = DateManager.getTimeMillis();
  1434.                         }
  1435.                         IDumpMessaggioService dumpMessageService = jdbcServiceManager.getDumpMessaggioService();
  1436.                         ContenutiUtilities contenutiUtilities = new ContenutiUtilities(this.log);
  1437.                         contenutiUtilities.insertContenuti(transazioneDTO, 
  1438.                                 transaction.getTracciaRichiesta(), transaction.getTracciaRisposta(), 
  1439.                                 transaction.getMsgDiagnostici(),
  1440.                                 dumpMessageService, transaction.getRisorse(), transaction.getTransactionServiceLibrary(), this.daoFactory);
  1441.                     }finally {
  1442.                         if(times!=null) {
  1443.                             long timeEnd =  DateManager.getTimeMillis();
  1444.                             long timeProcess = timeEnd-timeStart;
  1445.                             times.insertResources = timeProcess;
  1446.                         }
  1447.                     }
  1448.                 }
  1449.     
  1450.                 
  1451.                 String hdrTest = this.openspcoopProperties.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit();
  1452.                 if(hdrTest!=null && requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getHeaderFirstValue(hdrTest)!=null && 
  1453.                         this.fase.name().equals(requestInfo.getProtocolContext().getHeaderFirstValue(hdrTest))) {
  1454.                     throw new CoreException("Test Manually Exception generated in phase '"+this.fase+"'");
  1455.                 }
  1456.                 
  1457.     
  1458.                 // COMMIT
  1459.                 if(!autoCommit) {
  1460.                     try {
  1461.                         if(times!=null) {
  1462.                             timeStart = DateManager.getTimeMillis();
  1463.                         }
  1464.                         connection.commit();
  1465.                         
  1466.                         if(!tracceSalvate.isEmpty()) {
  1467.                             for (Traccia traccia : tracceSalvate) {
  1468.                                 traccia.setStored(true);
  1469.                             }
  1470.                         }
  1471.                         if(!diagnosticiSalvati.isEmpty()) {
  1472.                             for (MsgDiagnostico msgDiagnostico : diagnosticiSalvati) {
  1473.                                 msgDiagnostico.setStored(true);
  1474.                             }
  1475.                         }
  1476.                         if(!messaggiSalvati.isEmpty()) {
  1477.                             for (Messaggio messaggio : messaggiSalvati) {
  1478.                                 messaggio.setStored(true);
  1479.                             }
  1480.                         }
  1481.                         
  1482.                     }finally {
  1483.                         if(times!=null) {
  1484.                             long timeEnd =  DateManager.getTimeMillis();
  1485.                             long timeProcess = timeEnd-timeStart;
  1486.                             times.commit = timeProcess;
  1487.                         }
  1488.                     }
  1489.                 }
  1490.                 
  1491.                 
  1492.                 // DOPO COMMIT RIUSCITO
  1493.                 if(!autoCommit && insertTransazione &&
  1494.                     !FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)){
  1495.                     addTransactionAlreadyRegistered(info);
  1496.                 }
  1497.     
  1498.     
  1499.             } catch (SQLException sqlEx) {
  1500.                 errore = true;
  1501.                 try{
  1502.                     if(!autoCommit &&
  1503.                         connection!=null) {
  1504.                         connection.rollback();
  1505.                     }
  1506.                 }catch(Exception eRollback){
  1507.                     // ignore
  1508.                 }
  1509.                 // Effettuo il log anche nel core per evitare che un eventuale filtro a OFF sul core della PdD eviti la scrittura di questi errori
  1510.                 String msg = "Errore durante la scrittura della transazione sul database (sql): " + sqlEx.getLocalizedMessage();
  1511.                 this.logError("["+idTransazione+"] "+msg,sqlEx);
  1512.                 if(!FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)){
  1513.                     logRegistrazioneNonRiuscita(msgdiagErrore, false, sqlEx, idTransazione, 
  1514.                             null, null, null);
  1515.                 }
  1516.                 HandlerException errorDB = new HandlerException(msg,sqlEx); 
  1517.                 addTrackingException(info, errorDB);
  1518.                 if(dbEnabledBloccante) {
  1519.                     throw errorDB;
  1520.                 }
  1521.             }  catch (Exception e) {
  1522.                 errore = true;
  1523.                 try{
  1524.                     if(!autoCommit &&
  1525.                         connection!=null) {
  1526.                         connection.rollback();
  1527.                     }
  1528.                 }catch(Exception eRollback){
  1529.                     // ignore
  1530.                 }
  1531.                 // Effettuo il log anche nel core per evitare che un eventuale filtro a OFF sul core della PdD eviti la scrittura di questi errori
  1532.                 String msg = "Errore durante la scrittura della transazione sul database: " + e.getLocalizedMessage();
  1533.                 this.logError("["+idTransazione+"] "+msg,e);
  1534.                 if(!FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)){
  1535.                     logRegistrazioneNonRiuscita(msgdiagErrore, false, e, idTransazione, 
  1536.                             null, null, null);
  1537.                 }
  1538.                 HandlerException errorDB = new HandlerException(msg,e); 
  1539.                 addTrackingException(info, errorDB);
  1540.                 if(dbEnabledBloccante) {
  1541.                     throw errorDB;
  1542.                 }
  1543.             } finally {
  1544.                 
  1545.                 // Ripristino Autocomit
  1546.                 try {
  1547.                     if(!autoCommit &&
  1548.                         connection!=null) {
  1549.                         connection.setAutoCommit(true);
  1550.                     }
  1551.                 } catch (Exception e) {
  1552.                     // ignore
  1553.                 }
  1554.                                     
  1555.                 // Chiusura della connessione al database
  1556.                 try {
  1557.                     if(resource!=null)
  1558.                         dbManager.releaseResource(idDominio, modulo, resource);
  1559.                 } catch (Exception e) {
  1560.                     // ignore
  1561.                 }
  1562.                 
  1563.                 // Registrazione su FileSystem informazioni se la gestione e' andata in errore
  1564.                 if(errore && FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)){
  1565.                     
  1566.                     try {
  1567.                         exceptionSerializerFileSystem.registrazioneFileSystemDiagnosticiTracceDumpEmessiPdD(transaction, idTransazione, transazioneDTO,
  1568.                                 registraTracciaRichiesta, registraTracciaRisposta, registrazioneMessaggiDiagnostici, registrazioneDumpMessaggi);
  1569.                     } catch (Exception e) {
  1570.                         // ignore
  1571.                     }
  1572.                     try {
  1573.                         exceptionSerializerFileSystem.registrazioneFileSystem(transazioneDTO, idTransazione);
  1574.                     } catch (Exception e) {
  1575.                         // ignore
  1576.                     }
  1577.                 }
  1578.                                 
  1579.             }
  1580.                         
  1581.         }finally{

  1583.             this.releaseResourcesEngine(transaction, idTransazione, info);
  1584.                         
  1585.         }
  1586.         
  1587.         
  1588.         if(fileTraceException!=null) {
  1589.             throw fileTraceException;
  1590.         }
  1591.     }

  1593.     private ConfigurazioneTracciamento getConfigurazioneTracciamento(String idTransazione, Context context, TipoPdD tipoPorta, Transaction transaction){
  1594.         
  1595.         if(context!=null) {
  1596.             // nop
  1597.         }
  1598.         
  1599.         ConfigurazioneTracciamento configurazioneTracciamento = null;
  1600.         try {
  1601.             if(transaction!=null && transaction.getRequestInfo()!=null && 
  1602.                     transaction.getRequestInfo().getProtocolContext()!=null &&
  1603.                     transaction.getRequestInfo().getProtocolContext().getInterfaceName()!=null) {
  1604.                 switch (tipoPorta) {
  1605.                 case DELEGATA:
  1606.                     IDPortaDelegata idPD = new IDPortaDelegata();
  1607.                     idPD.setNome(transaction.getRequestInfo().getProtocolContext().getInterfaceName());
  1608.                     PortaDelegata pd = this.configPdDManager.getPortaDelegataSafeMethod(idPD, transaction.getRequestInfo());
  1609.                     configurazioneTracciamento = new ConfigurazioneTracciamento(this.log, this.configPdDManager, pd);
  1610.                     break;
  1611.                 case APPLICATIVA:
  1612.                     IDPortaApplicativa idPA = new IDPortaApplicativa();
  1613.                     idPA.setNome(transaction.getRequestInfo().getProtocolContext().getInterfaceName());
  1614.                     PortaApplicativa pa = this.configPdDManager.getPortaApplicativaSafeMethod(idPA, transaction.getRequestInfo());
  1615.                     configurazioneTracciamento = new ConfigurazioneTracciamento(this.log, this.configPdDManager, pa);
  1616.                     break;
  1617.                 default:
  1618.                     break;
  1619.                 }
  1620.             }
  1621.             if(configurazioneTracciamento==null) {
  1622.                 configurazioneTracciamento = new ConfigurazioneTracciamento(this.log, this.configPdDManager,tipoPorta);
  1623.             }
  1624.         }catch(Exception e) {
  1625.             this.logDebug("["+idTransazione+"] Errore avvenuto durante la lettura della configurazione del tracciamento: "+e.getMessage(),e); 
  1626.         }
  1627.         return configurazioneTracciamento;
  1628.     }
  1629.     
  1630.     private void releaseResourcesEngine(Transaction transactionParam, String idTransazione, InformazioniTransazione info) {
  1631.         
  1632.         if(!FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)) {
  1633.             return;
  1634.         }
  1635.         
  1636.         if(transactionParam!=null) {
  1637.             // nop
  1638.         }
  1639.         
  1640.         Transaction transaction = null;
  1641.         try {
  1642.             transaction = TransactionContext.removeTransaction(idTransazione);
  1643.             if(transaction!=null) {
  1644.                 transaction.setDeleted();
  1645.             }
  1646.             // altrimenti e' gia' stata eliminata
  1647.         } catch (Exception e) {
  1648.             this.logError("["+idTransazione+"] Errore durante la rimozione della registrazione delle transazione",e);
  1649.         }
  1650.             
  1651.         /* ---- Elimino informazione per filtro duplicati ----- */
  1652.         if(info!=null && info.getProtocollo()!=null){
  1653.             // Aggiunto check Applicativa e Delegata per evitare che comunicazioni dove i due domini sono entrambi gestiti sul solito GovWay si eliminano a vicenda gli id.
  1654.             if(TipoPdD.APPLICATIVA.equals(info.getTipoPorta()) && info.getProtocollo().getIdRichiesta()!=null){
  1655.                 try {
  1656.                     TransactionContext.removeIdentificativoProtocollo(info.getProtocollo().getIdRichiesta());
  1657.                 } catch (Exception e) {
  1658.                     this.logError("["+idTransazione+"] Errore durante la rimozione della registrazione dell'identificativo di protocollo della richiesta ["+info.getProtocollo().getIdRichiesta()+"]",e);
  1659.                 }
  1660.             }
  1661.             if(TipoPdD.DELEGATA.equals(info.getTipoPorta()) && info.getProtocollo().getIdRisposta()!=null){
  1662.                 try {
  1663.                     TransactionContext.removeIdentificativoProtocollo(info.getProtocollo().getIdRisposta());
  1664.                 } catch (Exception e) {
  1665.                     this.logError("["+idTransazione+"] Errore durante la rimozione della registrazione dell'identificativo di protocollo della risposta ["+info.getProtocollo().getIdRisposta()+"]",e);
  1666.                 }
  1667.             }
  1668.         }
  1669.         
  1670.     }
  1671.     
  1672.     private HandlerException logWithFileTrace(File fileTraceConfig, boolean fileTraceConfigGlobal,
  1673.             TransazioniProcessTimes times,
  1674.             Transazione transazioneDTO, Transaction transaction, EsitoTransazione esito,
  1675.             InformazioniToken informazioniToken,
  1676.             InformazioniAttributi informazioniAttributi,
  1677.             InformazioniNegoziazioneToken informazioniNegoziazioneToken,
  1678.             SecurityToken securityToken,
  1679.             InformazioniTransazione info,
  1680.             java.util.Map<String, List<String>> headerInUscita,
  1681.             RequestInfo requestInfo,
  1682.             String idTransazione,
  1683.             boolean fileTraceEnabledBloccante,
  1684.             org.openspcoop2.pdd.logger.MsgDiagnostico msgdiagErrore,
  1685.             boolean existsAnotherFiletraceTrackingPhase) {
  1686.         FileTraceManager fileTraceManager = null;
  1687.         long timeStart = -1;
  1688.         try {
  1689.             if(times!=null) {
  1690.                 timeStart = DateManager.getTimeMillis();
  1691.             }
  1692.             FileTraceConfig config = FileTraceConfig.getConfig(fileTraceConfig, fileTraceConfigGlobal);
  1693.             fileTraceManager = new FileTraceManager(this.log, config);
  1694.             fileTraceManager.buildTransazioneInfo(info.getProtocolFactory(), transazioneDTO, transaction, 
  1695.                     informazioniToken,
  1696.                     informazioniAttributi,
  1697.                     informazioniNegoziazioneToken,
  1698.                     securityToken,
  1699.                     info.getContext(),
  1700.                     headerInUscita,
  1701.                     this.fase);
  1702.             
  1703.             String hdrTest = this.openspcoopProperties.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog();
  1704.             if(hdrTest!=null && requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getHeaderFirstValue(hdrTest)!=null && 
  1705.                     this.fase.name().equals(requestInfo.getProtocolContext().getHeaderFirstValue(hdrTest))) {
  1706.                 throw new CoreException("Test Manually Exception generated (fileTrace) in phase '"+this.fase+"'");
  1707.             }
  1708.             
  1709.             fileTraceManager.invoke(info.getTipoPorta(), 
  1710.                     info.getContext(), requestInfo, TransazioneUtilities.convertToBusta(transazioneDTO),
  1711.                     this.fase);
  1712.                         
  1713.         }catch (Throwable e) {
  1714.             String error = "["+idTransazione+"] File trace fallito: "+e.getMessage();
  1715.             this.logError(error,e);
  1716.             BooleanNullable changeEsito = BooleanNullable.NULL();
  1717.             StringBuilder errorLog = new StringBuilder();
  1718.             logRegistrazioneNonRiuscita(msgdiagErrore, true, e, idTransazione,
  1719.                     transaction, changeEsito, errorLog);
  1720.             if(changeEsito.getValue()!=null && changeEsito.getValue().booleanValue()) {
  1721.                 esito = ServicesUtils.updateEsitoConAnomalie(esito, this.log, info.getProtocolFactory());
  1722.                 transazioneDTO.setEsito(esito.getCode());
  1723.                 if(transazioneDTO.getErrorLog()==null) {
  1724.                     transazioneDTO.setErrorLog(errorLog.toString());
  1725.                 }
  1726.             }
  1727.             if(fileTraceEnabledBloccante) {
  1728.                 return new HandlerException(error,e);
  1729.             }
  1730.         }finally {
  1731.             try {
  1732.                 if(!existsAnotherFiletraceTrackingPhase && fileTraceManager!=null) {
  1733.                     fileTraceManager.cleanResourcesForOnlyFileTrace(transaction);
  1734.                 }
  1735.             }catch(Exception eClean) {
  1736.                 this.logError("["+idTransazione+"] File trace 'clean' fallito: "+eClean.getMessage(),eClean);
  1737.             }
  1738.             if(times!=null) {
  1739.                 long timeEnd =  DateManager.getTimeMillis();
  1740.                 long timeProcess = timeEnd-timeStart;
  1741.                 times.fileTrace = timeProcess;
  1742.             }
  1743.         }
  1744.         
  1745.         return null;
  1746.     }
  1747.     
  1748.     
  1749.     private static final MapKey<String> TRACKING_EXCEPTION = org.openspcoop2.utils.Map.newMapKey("TRACKING_EXCEPTION");
  1750.     private static final MapKey<String> TRACKING_EXCEPTION_PHASE = org.openspcoop2.utils.Map.newMapKey("TRACKING_EXCEPTION_PHASE");
  1751.     private void throwTrackingExceptionIfExists(InformazioniTransazione info) throws HandlerException {
  1752.         if(info!=null && info.getContext()!=null && info.getContext().containsKey(TRACKING_EXCEPTION)) {
  1753.             HandlerException e = (HandlerException) info.getContext().get(TRACKING_EXCEPTION);
  1754.             FaseTracciamento faseExc = (FaseTracciamento) info.getContext().get(TRACKING_EXCEPTION_PHASE);
  1755.             String label = null;
  1756.             if(FaseTracciamento.IN_REQUEST.equals(faseExc)) {
  1757.                 label = CostantiLabel.LABEL_CONFIGURAZIONE_AVANZATA_REQ_IN;
  1758.             }
  1759.             else if(FaseTracciamento.OUT_REQUEST.equals(faseExc)) {
  1760.                 label = CostantiLabel.LABEL_CONFIGURAZIONE_AVANZATA_REQ_OUT;
  1761.             }
  1762.             else {
  1763.                 label = CostantiLabel.LABEL_CONFIGURAZIONE_AVANZATA_RES_OUT;
  1764.             }
  1765.             throw new HandlerException("database rilevato non disponibile nella fase '"+label+"': "+e.getMessage(),e);
  1766.         }
  1767.     }
  1768.     private void addTrackingException(InformazioniTransazione info, HandlerException e) {
  1769.         if(info!=null && info.getContext()!=null && !info.getContext().containsKey(TRACKING_EXCEPTION)) { 
  1770.             boolean add = false;
  1771.             if (
  1772.                     (
  1773.                         (
  1774.                                 FaseTracciamento.OUT_REQUEST.equals(this.fase)
  1775.                         ) 
  1776.                         &&
  1777.                         (
  1778.                                 this.openspcoopProperties.isTransazioniTracciamentoDBOutRequestThrowRequestException()
  1779.                         )
  1780.                     )
  1781.                     ||
  1782.                     (
  1783.                         (
  1784.                                 FaseTracciamento.IN_REQUEST.equals(this.fase) || 
  1785.                                 FaseTracciamento.OUT_REQUEST.equals(this.fase)
  1786.                         ) 
  1787.                         &&
  1788.                         (
  1789.                                 this.openspcoopProperties.isTransazioniTracciamentoDBOutResponseThrowRequestException() 
  1790.                                 || 
  1791.                                 this.openspcoopProperties.isTransazioniTracciamentoDBPostOutResponseThrowRequestException()
  1792.                         )
  1793.                     )
  1794.                     ||
  1795.                     (
  1796.                         (
  1797.                                 FaseTracciamento.OUT_RESPONSE.equals(this.fase)
  1798.                         ) 
  1799.                         &&
  1800.                         (
  1801.                                 this.openspcoopProperties.isTransazioniTracciamentoDBPostOutResponseThrowResponseException()
  1802.                         )
  1803.                     )
  1804.             ){
  1805.                 add = true;
  1806.             }
  1807.             if(add) {
  1808.                 info.getContext().put(TRACKING_EXCEPTION, e);
  1809.                 info.getContext().put(TRACKING_EXCEPTION_PHASE, this.fase);
  1810.             }
  1811.         }
  1812.     }
  1813.     
  1814.     
  1815.     private static final MapKey<String> TRANSACTION_REGISTERED = org.openspcoop2.utils.Map.newMapKey("TRANSACTION_REGISTERED");
  1816.     private boolean isTransactionAlreadyRegistered(InformazioniTransazione info) {
  1817.         return info!=null && info.getContext()!=null && info.getContext().containsKey(TRANSACTION_REGISTERED);
  1818.     }
  1819.     private void addTransactionAlreadyRegistered(InformazioniTransazione info) {
  1820.         if(info!=null && info.getContext()!=null) {
  1821.             info.getContext().put(TRANSACTION_REGISTERED, "true");
  1822.         }
  1823.     }
  1824.     private boolean registraTransazione(Transazione transazioneDTO, 
  1825.             ITransazioneService transazioneService, InformazioniTransazione info,
  1826.             boolean autoCommit, boolean registraTracciaRichiestaInfoTransazione, boolean registraTracciaRispostaInfoTransazione) throws ServiceException, NotImplementedException, NotFoundException, ExpressionNotImplementedException, ExpressionException {
  1827.         if(FaseTracciamento.IN_REQUEST.equals(this.fase) 
  1828.                 ||
  1829.                 !isTransactionAlreadyRegistered(info)) {
  1830.             /**System.out.println("["+this.fase+"]["+transazioneDTO.getIdTransazione()+"]["+transazioneDTO.getPddRuolo()+"]["+transazioneDTO.getPddCodice()+"]["+transazioneDTO.getNomeServizio()+"] INSERT con contesto["+transazioneDTO.getEsitoContesto()+"]");*/
  1831.             transazioneService.create(transazioneDTO);
  1832.             /**
  1833.              * DEVO AGGIUNGERLO DOPO IL COMMIT */
  1834.             if(autoCommit && !FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)){
  1835.                 addTransactionAlreadyRegistered(info);
  1836.             }
  1837.             return true;
  1838.         }
  1839.         else if(FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase) && info.getTransazioneDaAggiornare()!=null){
  1840.             /**System.out.println("["+this.fase+"]["+transazioneDTO.getIdTransazione()+"]["+transazioneDTO.getPddRuolo()+"]["+transazioneDTO.getPddCodice()+"]["+transazioneDTO.getNomeServizio()+"] UPDATE PUNTUALE con contesto["+transazioneDTO.getEsitoContesto()+"]");*/
  1841.             List<UpdateField> list = new ArrayList<>();
  1842.             list.add(new UpdateField(Transazione.model().ESITO, transazioneDTO.getEsito()));
  1843.             list.add(new UpdateField(Transazione.model().ESITO_SINCRONO, transazioneDTO.getEsitoSincrono()));
  1844.             list.add(new UpdateField(Transazione.model().ESITO_CONTESTO, transazioneDTO.getEsitoContesto()));
  1845.             list.add(new UpdateField(Transazione.model().CONSEGNE_MULTIPLE_IN_CORSO, transazioneDTO.getConsegneMultipleInCorso()));
  1846.             list.add(new UpdateField(Transazione.model().CODICE_RISPOSTA_USCITA, transazioneDTO.getCodiceRispostaUscita()));
  1847.             list.add(new UpdateField(Transazione.model().EVENTI_GESTIONE, transazioneDTO.getEventiGestione()));
  1848.             list.add(new UpdateField(Transazione.model().DATA_USCITA_RISPOSTA, transazioneDTO.getDataUscitaRisposta()));
  1849.             list.add(new UpdateField(Transazione.model().DATA_USCITA_RISPOSTA_STREAM, transazioneDTO.getDataUscitaRispostaStream()));
  1850.             list.add(new UpdateField(Transazione.model().RISPOSTA_INGRESSO_BYTES, transazioneDTO.getRispostaIngressoBytes()));
  1851.             list.add(new UpdateField(Transazione.model().RISPOSTA_USCITA_BYTES, transazioneDTO.getRispostaUscitaBytes()));
  1852.             list.add(new UpdateField(Transazione.model().FAULT_INTEGRAZIONE, transazioneDTO.getFaultIntegrazione()));
  1853.             list.add(new UpdateField(Transazione.model().FORMATO_FAULT_INTEGRAZIONE, transazioneDTO.getFormatoFaultIntegrazione()));
  1854.             list.add(new UpdateField(Transazione.model().FAULT_COOPERAZIONE, transazioneDTO.getFaultCooperazione()));
  1855.             list.add(new UpdateField(Transazione.model().FORMATO_FAULT_COOPERAZIONE, transazioneDTO.getFormatoFaultCooperazione()));
  1856.             list.add(new UpdateField(Transazione.model().ERROR_LOG, transazioneDTO.getErrorLog()));
  1857.             list.add(new UpdateField(Transazione.model().WARNING_LOG, transazioneDTO.getWarningLog()));
  1858.             
  1859.             // ** dati tracce **
  1860.             if(this.salvataggioTracceManager!=null) {
  1861.                 if(registraTracciaRichiestaInfoTransazione) {
  1862.                     list.add(new UpdateField(Transazione.model().TRACCIA_RICHIESTA, transazioneDTO.getTracciaRichiesta()));
  1863.                 }
  1864.                 if(registraTracciaRispostaInfoTransazione) {
  1865.                     list.add(new UpdateField(Transazione.model().TRACCIA_RISPOSTA, transazioneDTO.getTracciaRisposta()));
  1866.                 }
  1867.             }
  1868.             // ** dati diagnostica **
  1869.             if(this.salvataggioDiagnosticiManager!=null){
  1870.                 list.add(new UpdateField(Transazione.model().DIAGNOSTICI, transazioneDTO.getDiagnostici()));
  1871.                 list.add(new UpdateField(Transazione.model().DIAGNOSTICI_LIST_1, transazioneDTO.getDiagnosticiList1()));
  1872.                 list.add(new UpdateField(Transazione.model().DIAGNOSTICI_LIST_2, transazioneDTO.getDiagnosticiList2()));
  1873.                 list.add(new UpdateField(Transazione.model().DIAGNOSTICI_LIST_EXT, transazioneDTO.getDiagnosticiListExt()));
  1874.                 list.add(new UpdateField(Transazione.model().DIAGNOSTICI_EXT, transazioneDTO.getDiagnosticiExt()));
  1875.             }
  1876.             
  1877.             boolean isTransazioniUpdateUseDayInterval = this.openspcoopProperties.isTransazioniUpdateUseDayInterval();
  1878.             if(isTransazioniUpdateUseDayInterval) {
  1879.                 IExpression condition = transazioneService.newExpression();
  1880.                 Date left = DateUtils.convertToLeftInterval(transazioneDTO.getDataIngressoRichiesta(), UnitaTemporale.GIORNALIERO);
  1881.                 condition.greaterEquals(Transazione.model().DATA_INGRESSO_RICHIESTA, left);
  1882.                 Date right = DateUtils.convertToRightInterval(transazioneDTO.getDataIngressoRichiesta(), UnitaTemporale.GIORNALIERO);
  1883.                 condition.lessEquals(Transazione.model().DATA_INGRESSO_RICHIESTA, right);
  1884.                 transazioneService.updateFields(transazioneDTO.getIdTransazione(), condition, list.toArray(new UpdateField[1]));
  1885.             }
  1886.             else {
  1887.                 transazioneService.updateFields(transazioneDTO.getIdTransazione(), list.toArray(new UpdateField[1]));
  1888.             }
  1889.             return false;
  1890.         }
  1891.         else {
  1892.             /**System.out.println("["+this.fase+"]["+transazioneDTO.getIdTransazione()+"]["+transazioneDTO.getPddRuolo()+"]["+transazioneDTO.getPddCodice()+"]["+transazioneDTO.getNomeServizio()+"] UPDATE con contesto["+transazioneDTO.getEsitoContesto()+"]");*/
  1893.             
  1894.             boolean isTransazioniUpdateUseDayInterval = this.openspcoopProperties.isTransazioniUpdateUseDayInterval();
  1895.             if(isTransazioniUpdateUseDayInterval) {
  1896.                 TransazioneDaoExt ext = new TransazioneDaoExt(transazioneDTO);
  1897.                 ext.setUseDayIntervalForUpdate(true);
  1898.                 transazioneService.update(transazioneDTO.getIdTransazione(), ext);
  1899.             }
  1900.             else {
  1901.                 transazioneService.update(transazioneDTO.getIdTransazione(), transazioneDTO);
  1902.             }
  1903.             return false;
  1904.         }
  1905.     }
  1906.     
  1907.     private void logRegistrazioneNonRiuscita(org.openspcoop2.pdd.logger.MsgDiagnostico msgdiagErrore, boolean fileTrace, Throwable e, String idTransazione,
  1908.             Transaction transaction, BooleanNullable changeEsito, StringBuilder sbErrorLog) {
  1909.         if(fileTrace || !FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase)){
  1910.             try {
  1911.                 msgdiagErrore.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE, e.getMessage());
  1912.                 msgdiagErrore.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, fileTrace ? "fileTrace" : "database");
  1913.                 switch (this.fase) {
  1914.                 case IN_REQUEST:
  1915.                     msgdiagErrore.addKeyword(CostantiPdD.KEY_FASE_TRACCIAMENTO, CostantiLabel.LABEL_CONFIGURAZIONE_AVANZATA_REQ_IN);
  1916.                     break;
  1917.                 case OUT_REQUEST:
  1918.                     msgdiagErrore.addKeyword(CostantiPdD.KEY_FASE_TRACCIAMENTO, CostantiLabel.LABEL_CONFIGURAZIONE_AVANZATA_REQ_OUT);
  1919.                     break;
  1920.                 case OUT_RESPONSE:
  1921.                     msgdiagErrore.addKeyword(CostantiPdD.KEY_FASE_TRACCIAMENTO, CostantiLabel.LABEL_CONFIGURAZIONE_AVANZATA_RES_OUT);
  1922.                     break;
  1923.                 case POST_OUT_RESPONSE:
  1924.                     msgdiagErrore.addKeyword(CostantiPdD.KEY_FASE_TRACCIAMENTO, CostantiLabel.LABEL_CONFIGURAZIONE_AVANZATA_RES_OUT_COMPLETE);
  1925.                     break;
  1926.                 }
  1927.                 if(FaseTracciamento.POST_OUT_RESPONSE.equals(this.fase) && transaction!=null) {
  1928.                     // siamo per forza in fileTrace
  1929.                     msgdiagErrore.addLogPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_TRACCIAMENTO, "registrazioneTransazioneNonRiuscita", transaction, sbErrorLog);
  1930.                     if(changeEsito!=null) {
  1931.                         changeEsito.setValue(true);
  1932.                     }
  1933.                 }
  1934.                 else {
  1935.                     msgdiagErrore.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_TRACCIAMENTO, "registrazioneTransazioneNonRiuscita");
  1936.                 }
  1937.             }catch(Throwable t) {
  1938.                 String error = "["+idTransazione+"] Registrazione dell'anomalia avvenuta durante il tracciamento non riuscita: "+t.getMessage();
  1939.                 this.log.error(error,t);
  1940.             }
  1941.         }
  1942.     }
  1943. }
Created with JaCoCo 0.8.8.202204050719