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




  24. package org.openspcoop2.pdd.logger;

  26. import java.io.ByteArrayOutputStream;
  27. import java.sql.Connection;
  28. import java.util.Date;
  29. import java.util.List;
  30. import java.util.Map;

  32. import javax.mail.BodyPart;
  33. import javax.xml.soap.AttachmentPart;
  34. import javax.xml.soap.SOAPBody;

  36. import org.openspcoop2.core.constants.TipoPdD;
  37. import org.openspcoop2.core.id.IDSoggetto;
  38. import org.openspcoop2.message.OpenSPCoop2Message;
  39. import org.openspcoop2.message.constants.MessageRole;
  40. import org.openspcoop2.message.constants.MessageType;
  41. import org.openspcoop2.message.constants.ServiceBinding;
  42. import org.openspcoop2.message.rest.MultipartContent;
  43. import org.openspcoop2.message.soap.SoapUtils;
  44. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  45. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  46. import org.openspcoop2.pdd.core.CostantiPdD;
  47. import org.openspcoop2.pdd.core.PdDContext;
  48. import org.openspcoop2.pdd.core.connettori.ConnettoreUtils;
  49. import org.openspcoop2.pdd.core.handlers.GeneratoreCasualeDate;
  50. import org.openspcoop2.pdd.core.transazioni.RepositoryGestioneStateful;
  51. import org.openspcoop2.pdd.core.transazioni.Transaction;
  52. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  53. import org.openspcoop2.pdd.core.transazioni.TransactionDeletedException;
  54. import org.openspcoop2.pdd.core.transazioni.TransactionNotExistsException;
  55. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  56. import org.openspcoop2.protocol.engine.builder.TracciaBuilder;
  57. import org.openspcoop2.protocol.sdk.Allegato;
  58. import org.openspcoop2.protocol.sdk.Busta;
  59. import org.openspcoop2.protocol.sdk.BustaRawContent;
  60. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  61. import org.openspcoop2.protocol.sdk.SecurityInfo;
  62. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  63. import org.openspcoop2.protocol.sdk.constants.TipoSerializzazione;
  64. import org.openspcoop2.protocol.sdk.state.IState;
  65. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  66. import org.openspcoop2.protocol.sdk.state.StateMessage;
  67. import org.openspcoop2.protocol.sdk.tracciamento.EsitoElaborazioneMessaggioTracciato;
  68. import org.openspcoop2.protocol.sdk.tracciamento.ITracciaProducer;
  69. import org.openspcoop2.protocol.sdk.tracciamento.Traccia;
  70. import org.openspcoop2.protocol.sdk.tracciamento.TracciamentoException;
  71. import org.openspcoop2.utils.MapKey;
  72. import org.openspcoop2.utils.date.DateManager;
  73. import org.openspcoop2.utils.mime.MimeMultipart;
  74. import org.openspcoop2.utils.transport.http.HttpConstants;
  75. import org.slf4j.Logger;


  78. /**
  79.  * Contiene la definizione un Logger utilizzato dai nodi dell'infrastruttura di OpenSPCoop
  80.  * per il tracciamento di buste.
  81.  *
  82.  * @author Poli Andrea (apoli@link.it)
  83.  * @author $Author$
  84.  * @version $Rev$, $Date$
  85.  */

  87. public class Tracciamento {

  89.     /** Indicazione di un tracciamento funzionante */
  90.     public static boolean tracciamentoDisponibile = true;
  91.     /** Primo errore avvenuto nel momento in cui è stato rilevato un malfunzionamento nel tracciamento */
  92.     public static Exception motivoMalfunzionamentoTracciamento = null;
  93.     
  94.     /**  Logger log4j utilizzato per scrivere i tracciamenti */
  95.     protected Logger loggerTracciamento = null;

  97.     /** Tipo Gateway */
  98.     private TipoPdD tipoPdD;
  99.     
  100.     /** Soggetto che richiede il logger */
  101.     private IDSoggetto idSoggettoDominio;
  102.     
  103.     /** PdDContext */
  104.     private PdDContext pddContext;
  105.     
  106.     /** RequestInfo */
  107.     private RequestInfo requestInfo = null;
  108.     
  109.     /** Protocol Factory */
  110.     private ProtocolFactoryManager protocolFactoryManager = null;
  111.     private IProtocolFactory<?> protocolFactory;
  112.     private boolean tracciamentoSupportatoProtocollo = true;
  113.     
  114.     /** Appender personalizzati per i tracciamenti di OpenSPCoop */
  115.     private List<ITracciaProducer> loggerTracciamentoOpenSPCoopAppender = null; 
  116.     private List<String> tipoTracciamentoOpenSPCoopAppender = null; 

  118.     /** Reader della configurazione di OpenSPCoop */
  119.     private ConfigurazionePdDManager _configurazionePdDReader;
  120.     
  121.     /** Stati */
  122.     private StateMessage state = null;
  123.     private StateMessage responseState = null;
  124.     
  125.     /** XMLBuilder */
  126.     private TracciaBuilder xmlBuilder;

  128.     /** MsgDiagnostico per eventuali errori di tracciamento */
  129.     private MsgDiagnostico msgDiagErroreTracciamento = null;
  130.     
  131.     /** OpenSPCoopProperties */
  132.     private OpenSPCoop2Properties openspcoopProperties = null;
  133.     
  134.     /** Generatore di date casuali*/
  135.     private GeneratoreCasualeDate generatoreDateCasuali = null;
  136.     
  137.     /** Transaction */
  138.     private Transaction transactionNullable = null;
  139.     
  140.     public static String createLocationString(boolean bustaRicevuta,String location){
  141.         if(bustaRicevuta)
  142.             return ConnettoreUtils.limitLocation255Character(CostantiPdD.TRACCIAMENTO_IN+HttpConstants.SEPARATOR_SOURCE+location);
  143.         else
  144.             return ConnettoreUtils.limitLocation255Character(CostantiPdD.TRACCIAMENTO_OUT+HttpConstants.SEPARATOR_SOURCE+location);
  145.     }
  146.     
  147.     
  148.     public Tracciamento(IDSoggetto idSoggettoDominio,String idFunzione,PdDContext pddContext,TipoPdD tipoPdD,String nomePorta, 
  149.             ConfigurazionePdDManager configurazionePdDManager) throws TracciamentoException {
  150.         this(idSoggettoDominio, idFunzione, pddContext, tipoPdD, nomePorta, 
  151.                 configurazionePdDManager, null, null);  
  152.     }
  153.     /*
  154.     public Tracciamento(IDSoggetto idSoggettoDominio,String idFunzione,PdDContext pddContext,TipoPdD tipoPdD,String nomePorta, 
  155.             IState statoRichiesta,IState statoRisposta) throws TracciamentoException {
  156.         this(idSoggettoDominio, idFunzione, pddContext, tipoPdD, nomePorta, 
  157.                 null, statoRichiesta, statoRisposta);   
  158.     }
  159.     */
  160.     private Tracciamento(IDSoggetto idSoggettoDominio,String idFunzione,PdDContext pddContext,TipoPdD tipoPdD,String nomePorta, 
  161.             ConfigurazionePdDManager configurazionePdDManagerParam, IState stateParam,IState responseStateParam) throws TracciamentoException {
  162.         this.idSoggettoDominio = idSoggettoDominio;
  163.         this.pddContext=pddContext;
  164.         this.tipoPdD = tipoPdD;
  165.                 
  166.         this.loggerTracciamento = OpenSPCoop2Logger.loggerTracciamento;
  167.         this.loggerTracciamentoOpenSPCoopAppender = OpenSPCoop2Logger.loggerTracciamentoOpenSPCoopAppender;
  168.         this.tipoTracciamentoOpenSPCoopAppender = OpenSPCoop2Logger.tipoTracciamentoOpenSPCoopAppender;
  169.         
  170.         if(configurazionePdDManagerParam!=null) {
  171.             this._configurazionePdDReader = configurazionePdDManagerParam;
  172.             this.state = this._configurazionePdDReader.getState();
  173.             this.responseState = this._configurazionePdDReader.getResponseState();
  174.         }
  175.         else {
  176.             if(stateParam!=null && stateParam instanceof StateMessage){
  177.                 this.state = (StateMessage) stateParam;
  178.             }
  179.             if(responseStateParam!=null && responseStateParam instanceof StateMessage){
  180.                 this.responseState = (StateMessage) responseStateParam;
  181.             }
  182.             this._configurazionePdDReader = ConfigurazionePdDManager.getInstance(this.state, this.responseState);
  183.         }
  184.         
  185.         if(pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  186.             this.requestInfo = (RequestInfo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  187.         }
  188.         
  189.         this.msgDiagErroreTracciamento = MsgDiagnostico.newInstance(tipoPdD,idSoggettoDominio,idFunzione,nomePorta, this.requestInfo ,this._configurazionePdDReader);
  190.         this.msgDiagErroreTracciamento.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TRACCIAMENTO);
  191.         try{
  192.             if(this.pddContext==null) {
  193.                 throw new Exception("PdDContext is null");
  194.             }
  195.             this.protocolFactoryManager = ProtocolFactoryManager.getInstance();
  196.             this.protocolFactory = this.protocolFactoryManager.getProtocolFactoryByName((String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  197.             this.tracciamentoSupportatoProtocollo = this.protocolFactory.createProtocolConfiguration().isAbilitataGenerazioneTracce();
  198.         } catch(Throwable e){
  199.             throw new TracciamentoException(e.getMessage(),e);
  200.         }
  201.         this.xmlBuilder = new TracciaBuilder(this.protocolFactory);
  202.         this.openspcoopProperties = OpenSPCoop2Properties.getInstance();
  203.         if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato()){
  204.             this.generatoreDateCasuali = GeneratoreCasualeDate.getGeneratoreCasualeDate();
  205.         }
  206.         
  207.         try{
  208.             if(this.pddContext!=null && this.pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) {
  209.                 String idTransazione = (String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  210.                 this.transactionNullable = TransactionContext.getTransaction(idTransazione);
  211.             }
  212.         }catch(Exception e){
  213.             // La transazione potrebbe essere stata eliminata nelle comunicazioni stateful
  214.         }
  215.     }
  216.     
  217.     private ConfigurazionePdDManager getConfigurazionePdDManager() {
  218.         if(this._configurazionePdDReader!=null) {
  219.             return this._configurazionePdDReader;
  220.         }
  221.         if(this.state!=null || this.responseState!=null) {
  222.             return ConfigurazionePdDManager.getInstance(this.state, this.responseState);
  223.         }
  224.         return ConfigurazionePdDManager.getInstance();
  225.     }
  226.     

  228.     public void updateState(IState requestStateParam, IState responseStateParam) {
  229.         StateMessage requestState = null;
  230.         StateMessage responseState = null;
  231.         if(requestStateParam!=null && requestStateParam instanceof StateMessage) {
  232.             requestState = (StateMessage) requestStateParam;
  233.         }
  234.         if(responseStateParam!=null && responseStateParam instanceof StateMessage) {
  235.             responseState = (StateMessage) responseStateParam;
  236.         }
  237.         updateState(requestState, responseState);
  238.     }
  239.     public void updateState(StateMessage requestState, StateMessage responseState){
  240.         this.state = requestState;
  241.         this.responseState = responseState;
  242.         if(this.state!=null || this.responseState!=null) {
  243.             if(this._configurazionePdDReader!=null) {
  244.                 this._configurazionePdDReader = this._configurazionePdDReader.refreshState(this.state, this.responseState);
  245.             }
  246.             else {
  247.                 this._configurazionePdDReader = ConfigurazionePdDManager.getInstance(this.state, this.responseState);
  248.             }
  249.         }
  250.         else {
  251.             this._configurazionePdDReader = ConfigurazionePdDManager.getInstance();
  252.         }
  253.     }
  254.     public void updateState(ConfigurazionePdDManager configurazionePdDManager){
  255.         this._configurazionePdDReader = configurazionePdDManager;
  256.         if(this._configurazionePdDReader!=null) {
  257.             this.state = this._configurazionePdDReader.getState();
  258.             this.responseState = this._configurazionePdDReader.getResponseState();
  259.         }
  260.     }
  261.     


  264.     /**
  265.      * Il Metodo si occupa di impostare il dominio del Soggetto che utilizza il logger. 
  266.      *
  267.      * @param dominio Soggetto che richiede il logger
  268.      * 
  269.      */
  270.     public void setDominio(IDSoggetto dominio){
  271.         this.idSoggettoDominio = dominio;
  272.     }


  275.     private Connection getConnectionFromState(boolean richiesta){
  276.         if(richiesta){
  277.             Connection c = StateMessage.getConnection(this.state);
  278.             if(c!=null) {
  279.                 return c;
  280.             }
  281.         }
  282.         else{
  283.             Connection c = StateMessage.getConnection(this.responseState);
  284.             if(c!=null) {
  285.                 return c;
  286.             }
  287.         }
  288.         return null;
  289.     }
  290.     
  291.     




  296.     /** ----------------- METODI DI LOGGING (Tracciamento buste) ---------------- */

  298.     /**
  299.      * Il Metodo si occupa di tracciare una busta di richiesta.
  300.      *
  301.      * @param busta Busta da registrare
  302.      * 
  303.      */
  304.     @Deprecated
  305.     public void registraRichiesta(OpenSPCoop2Message msg,SecurityInfo securityInfo,
  306.             Busta busta,EsitoElaborazioneMessaggioTracciato esito,String location) throws TracciamentoException {
  307.         registraRichiesta(msg,securityInfo,busta,esito,location,null);
  308.     }
  309.     @Deprecated
  310.     public void registraRichiesta(OpenSPCoop2Message msg,SecurityInfo securityInfo,
  311.             Busta busta,EsitoElaborazioneMessaggioTracciato esito,String location, 
  312.             String idCorrelazioneApplicativa) throws TracciamentoException {
  313.         
  314.         if(this.transactionNullable!=null) {
  315.             this.transactionNullable.getTempiElaborazione().startTracciamentoRichiesta();
  316.         }
  317.         try {
  318.             if(this.tracciamentoSupportatoProtocollo && this.getConfigurazionePdDManager().tracciamentoBuste()){
  319.                 String xml = null;
  320.                 boolean erroreAppender = false;
  321.                 
  322.                 // Data
  323.                 Date gdo = DateManager.getDate();
  324.                 if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  325.                     gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  326.                     busta.setOraRegistrazione(gdo);
  327.                 }
  328.                 
  329.                 // Traccia
  330.                 Traccia traccia = this.getTraccia(busta, msg,securityInfo, esito, gdo, RuoloMessaggio.RICHIESTA, location, idCorrelazioneApplicativa);
  331.                 
  332.                 try{
  333.                     
  334.                     // Miglioramento performance
  335.                     if(OpenSPCoop2Logger.loggerTracciamentoAbilitato){
  336.                         xml = this.xmlBuilder.toString(traccia,TipoSerializzazione.DEFAULT);
  337.                         if(xml==null)
  338.                             throw new Exception("Traccia non costruita");
  339.                         this.loggerTracciamento.info(xml);
  340.                     }
  341.     
  342.                     // TransazioneContext
  343.                     if(this.openspcoopProperties.isTransazioniSaveTracceInUniqueTransaction()) {
  344.                         this.logTracciaInTransactionContext(traccia, true);
  345.                     }
  346.                     
  347.                     //  Tracciamento personalizzato
  348.                     for(int i=0; i<this.loggerTracciamentoOpenSPCoopAppender.size();i++){
  349.                         try{
  350.                             this.loggerTracciamentoOpenSPCoopAppender.get(i).log(getConnectionFromState(true), traccia);
  351.                         }catch(Exception e){
  352.                             logError("Errore durante il tracciamento personalizzato ["+this.tipoTracciamentoOpenSPCoopAppender.get(i)+"] della richiesta: "+e.getMessage()+". Traccia non registrata:\n"+xml,e);
  353.                             try{
  354.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, RuoloMessaggio.RICHIESTA.toString());
  355.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA, xml);
  356.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_PERSONALIZZATO,this.tipoTracciamentoOpenSPCoopAppender.get(i));
  357.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  358.                                 this.msgDiagErroreTracciamento.logPersonalizzato("registrazioneNonRiuscita.openspcoopAppender");
  359.                             }catch(Exception eMsg){
  360.                                 // ignore
  361.                             }
  362.                             if(this.openspcoopProperties.isTracciaturaFallita_BloccaCooperazioneInCorso()){
  363.                                 erroreAppender = true;
  364.                                 throw e; // Rilancio
  365.                             }
  366.                         }
  367.                     }
  368.                 }catch(Exception e){
  369.                     // check eventuale costruzione dell'xml non fatto per log4j disabilitato.
  370.                     if( (xml==null) && (OpenSPCoop2Logger.loggerTracciamentoAbilitato==false) ){
  371.                         try{
  372.                             xml = this.xmlBuilder.toString(traccia,TipoSerializzazione.DEFAULT);
  373.                         }catch(Exception eBuild){}
  374.                     }
  375.                     if(xml==null){
  376.                         logError("Errore durante la costruzione della traccia: "+e.getMessage(),e);
  377.                     }else{
  378.                         logError("Errore durante il tracciamento della richiesta: "+e.getMessage()+". Traccia non registrata:\n"+xml,e);
  379.                         if(!erroreAppender){
  380.                             try{
  381.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, RuoloMessaggio.RICHIESTA.toString());
  382.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA, xml);
  383.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  384.                                 this.msgDiagErroreTracciamento.logPersonalizzato("registrazioneNonRiuscita");
  385.                             }catch(Exception eMsg){}
  386.                         }
  387.                     }
  388.                     gestioneErroreTracciamento(e);
  389.                 }
  390.             }
  391.         }finally {
  392.             if(this.transactionNullable!=null) {
  393.                 this.transactionNullable.getTempiElaborazione().endTracciamentoRichiesta();
  394.             }
  395.         }
  396.     }
  397.     /**
  398.      * Il Metodo si occupa di tracciare una busta di richiesta.
  399.      *
  400.      * @param busta Busta da registrare in byte
  401.      * @param bustaObject Busta da registrare (per appender personalizzati)
  402.      * 
  403.      */
  404.     @Deprecated
  405.     public void registraRichiesta(OpenSPCoop2Message msg,SecurityInfo securityInfo,
  406.             byte[] busta,Busta bustaObject,EsitoElaborazioneMessaggioTracciato esito,String location) throws TracciamentoException {
  407.         registraRichiesta(msg,securityInfo,busta,bustaObject,esito,location,null);
  408.     }
  409.     @Deprecated
  410.     public void registraRichiesta(OpenSPCoop2Message msg,SecurityInfo securityInfo,
  411.             byte[] busta,Busta bustaObject,EsitoElaborazioneMessaggioTracciato esito,String location, 
  412.             String idCorrelazioneApplicativa) throws TracciamentoException {
  413.         if(this.transactionNullable!=null) {
  414.             this.transactionNullable.getTempiElaborazione().startTracciamentoRichiesta();
  415.         }
  416.         try {
  417.             if(this.tracciamentoSupportatoProtocollo && this.getConfigurazionePdDManager().tracciamentoBuste()){
  418.                 String xml = null;
  419.                 boolean erroreAppender = false;
  420.                 
  421.                 // Data
  422.                 Date gdo = DateManager.getDate();
  423.                 if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  424.                     gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  425.                     bustaObject.setOraRegistrazione(gdo);
  426.                 }
  427.                 
  428.                 // Traccia
  429.                 Traccia traccia = this.getTraccia(bustaObject, msg, securityInfo, esito, gdo, RuoloMessaggio.RICHIESTA, location, idCorrelazioneApplicativa);
  430.                 traccia.setBustaAsByteArray(busta);
  431.                 
  432.                 try{
  433.             
  434.                     // Miglioramento performance
  435.                     if(OpenSPCoop2Logger.loggerTracciamentoAbilitato){
  436.                         xml = this.xmlBuilder.toString(traccia,TipoSerializzazione.DEFAULT);
  437.                         if(xml==null)
  438.                             throw new Exception("Traccia non costruita");
  439.                         this.loggerTracciamento.info(xml);
  440.                     }
  441.                     
  442.                     // TransazioneContext
  443.                     if(this.openspcoopProperties.isTransazioniSaveTracceInUniqueTransaction()) {
  444.                         this.logTracciaInTransactionContext(traccia, true);
  445.                     }
  446.                         
  447.                     // Tracciamento personalizzato
  448.                     for(int i=0; i<this.loggerTracciamentoOpenSPCoopAppender.size();i++){
  449.                         try{
  450.                             this.loggerTracciamentoOpenSPCoopAppender.get(i).log(getConnectionFromState(true), traccia);
  451.                         }catch(Exception e){
  452.                             logError("Errore durante il tracciamento personalizzato ["+this.tipoTracciamentoOpenSPCoopAppender.get(i)+"] della richiesta: "+e.getMessage()+". Traccia non registrata:\n"+xml,e);
  453.                             try{
  454.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, RuoloMessaggio.RICHIESTA.toString());
  455.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA, xml);
  456.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_PERSONALIZZATO,this.tipoTracciamentoOpenSPCoopAppender.get(i));
  457.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  458.                                 this.msgDiagErroreTracciamento.logPersonalizzato("registrazioneNonRiuscita.openspcoopAppender");
  459.                             }catch(Exception eMsg){
  460.                                 // ignore
  461.                             }
  462.                             if(this.openspcoopProperties.isTracciaturaFallita_BloccaCooperazioneInCorso()){
  463.                                 erroreAppender = true;
  464.                                 throw e; // Rilancio
  465.                             }
  466.                         }
  467.                     }
  468.                 }catch(Exception e){
  469.                     // check eventuale costruzione dell'xml non fatto per log4j disabilitato.
  470.                     if( (xml==null) && (OpenSPCoop2Logger.loggerTracciamentoAbilitato==false) ){
  471.                         try{
  472.                             xml = this.xmlBuilder.toString(traccia,TipoSerializzazione.DEFAULT);
  473.                         }catch(Exception eBuild){}
  474.                     }
  475.                     if(xml==null){
  476.                         logError("Errore durante la costruzione della traccia: "+e.getMessage(),e);
  477.                     }else{
  478.                         logError("Errore durante il tracciamento della richiesta: "+e.getMessage()+". Traccia non registrata:\n"+xml,e);
  479.                         if(!erroreAppender){
  480.                             try{
  481.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, RuoloMessaggio.RICHIESTA.toString());
  482.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA, xml);
  483.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  484.                                 this.msgDiagErroreTracciamento.logPersonalizzato("registrazioneNonRiuscita");
  485.                             }catch(Exception eMsg){}
  486.                         }
  487.                     }
  488.                     gestioneErroreTracciamento(e);
  489.                 }
  490.             }
  491.         }finally {
  492.             if(this.transactionNullable!=null) {
  493.                 this.transactionNullable.getTempiElaborazione().endTracciamentoRichiesta();
  494.             }
  495.         }
  496.     }
  497.     /**
  498.      * Il Metodo si occupa di tracciare una busta di richiesta.
  499.      *
  500.      * @param busta Busta da registrare
  501.      * @param bustaObject Busta da registrare (per appender personalizzati)
  502.      * 
  503.      */
  504.     public void registraRichiesta(OpenSPCoop2Message msg,SecurityInfo securityInfo,
  505.             BustaRawContent<?> busta,Busta bustaObject,EsitoElaborazioneMessaggioTracciato esito, String location) throws TracciamentoException {
  506.         registraRichiesta(msg,securityInfo,busta,bustaObject,esito,location,null);
  507.     }
  508.     public void registraRichiesta(OpenSPCoop2Message msg,SecurityInfo securityInfo,
  509.             BustaRawContent<?> busta,Busta bustaObject,EsitoElaborazioneMessaggioTracciato esito, String location, 
  510.             String idCorrelazioneApplicativa) throws TracciamentoException {
  511.         if(this.transactionNullable!=null) {
  512.             this.transactionNullable.getTempiElaborazione().startTracciamentoRichiesta();
  513.         }
  514.         try {
  515.             if(this.tracciamentoSupportatoProtocollo && this.getConfigurazionePdDManager().tracciamentoBuste()) {
  516.                 String xml = null;
  517.                 boolean erroreAppender = false;
  518.                 
  519.                 // Data
  520.                 Date gdo = DateManager.getDate();
  521.                 if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  522.                     gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  523.                     bustaObject.setOraRegistrazione(gdo);
  524.                 }
  525.                 
  526.                 // Traccia
  527.                 Traccia traccia = this.getTraccia(bustaObject, msg, securityInfo, esito, gdo, RuoloMessaggio.RICHIESTA, location, idCorrelazioneApplicativa);
  528.                 boolean saveHeader = true;
  529.                 try {
  530.                     saveHeader = (this.protocolFactory==null || this.protocolFactory.createProtocolConfiguration().isAbilitatoSalvataggioHeaderProtocolloTracce());
  531.                 }catch(Throwable e) {
  532.                     this.logError("Comprensione opzione 'salvataggio header protocollo tracce' fallita: "+e.getMessage(), new Exception(e));
  533.                 }
  534.                 if(saveHeader) {
  535.                     traccia.setBustaAsRawContent(busta);
  536.                 }
  537.                 
  538.                 try{
  539.                     
  540.                     // Miglioramento performance
  541.                     if(OpenSPCoop2Logger.loggerTracciamentoAbilitato){
  542.                         xml = this.xmlBuilder.toString(traccia,TipoSerializzazione.DEFAULT);
  543.                         if(xml==null)
  544.                             throw new Exception("Traccia non costruita");
  545.                         this.loggerTracciamento.info(xml);
  546.                     }
  547.                         
  548.                     // TransazioneContext
  549.                     if(this.openspcoopProperties.isTransazioniSaveTracceInUniqueTransaction()) {
  550.                         this.logTracciaInTransactionContext(traccia, true);
  551.                     }
  552.                     
  553.                     // Tracciamento personalizzato
  554.                     for(int i=0; i<this.loggerTracciamentoOpenSPCoopAppender.size();i++){
  555.                         try{
  556.                             this.loggerTracciamentoOpenSPCoopAppender.get(i).log(getConnectionFromState(true), traccia);
  557.                         } catch(Exception e){
  558.                             logError("Errore durante il tracciamento personalizzato ["+this.tipoTracciamentoOpenSPCoopAppender.get(i)+"] della richiesta: "+e.getMessage()+". Traccia non registrata:\n"+xml,e);
  559.                             try{
  560.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, RuoloMessaggio.RICHIESTA.toString());
  561.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA, xml);
  562.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_PERSONALIZZATO,this.tipoTracciamentoOpenSPCoopAppender.get(i));
  563.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  564.                                 this.msgDiagErroreTracciamento.logPersonalizzato("registrazioneNonRiuscita.openspcoopAppender");
  565.                             }catch(Exception eMsg){
  566.                                 // ignore
  567.                             }
  568.                             if(this.openspcoopProperties.isTracciaturaFallita_BloccaCooperazioneInCorso()){
  569.                                 erroreAppender = true;
  570.                                 throw e; // Rilancio
  571.                             }
  572.                         }
  573.                     }
  574.                 }catch(Exception e){
  575.                     // check eventuale costruzione dell'xml non fatto per log4j disabilitato.
  576.                     if( (xml==null) && (OpenSPCoop2Logger.loggerTracciamentoAbilitato==false) ){
  577.                         try{
  578.                             xml = this.xmlBuilder.toString(traccia,TipoSerializzazione.DEFAULT);
  579.                         }catch(Exception eBuild){}
  580.                     }
  581.                     if(xml==null){
  582.                         logError("Errore durante la costruzione della traccia: "+e.getMessage(),e);
  583.                     }else{
  584.                         logError("Errore durante il tracciamento della richiesta: "+e.getMessage()+". Traccia non registrata:\n"+xml,e);
  585.                         if(!erroreAppender){
  586.                             try{
  587.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, RuoloMessaggio.RICHIESTA.toString());
  588.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA, xml);
  589.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  590.                                 this.msgDiagErroreTracciamento.logPersonalizzato("registrazioneNonRiuscita");
  591.                             }catch(Exception eMsg){}
  592.                         }
  593.                     }
  594.                     gestioneErroreTracciamento(e);
  595.                 }
  596.             }
  597.         }finally {
  598.             if(this.transactionNullable!=null) {
  599.                 this.transactionNullable.getTempiElaborazione().endTracciamentoRichiesta();
  600.             }
  601.         }
  602.     }
  603.     



  607.     /**
  608.      * Il Metodo si occupa di tracciare una busta di risposta.
  609.      *
  610.      * @param busta Busta da registrare
  611.      * 
  612.      */
  613.     @Deprecated
  614.     public void registraRisposta(OpenSPCoop2Message msg,SecurityInfo securityInfo,
  615.             Busta busta,EsitoElaborazioneMessaggioTracciato esito, String location) throws TracciamentoException {
  616.         registraRisposta(msg,securityInfo,busta,esito,location,null,null);
  617.     }
  618.     @Deprecated
  619.     public void registraRisposta(OpenSPCoop2Message msg,SecurityInfo securityInfo,
  620.             Busta busta,EsitoElaborazioneMessaggioTracciato esito, String location, 
  621.             String idCorrelazioneApplicativa, String idCorrelazioneApplicativaRisposta) throws TracciamentoException {
  622.         if(this.transactionNullable!=null) {
  623.             this.transactionNullable.getTempiElaborazione().startTracciamentoRisposta();
  624.         }
  625.         try {
  626.             if(this.tracciamentoSupportatoProtocollo && this.getConfigurazionePdDManager().tracciamentoBuste()){
  627.                 String xml = null;
  628.                 boolean erroreAppender = false;
  629.                 
  630.                 // Data
  631.                 Date gdo = DateManager.getDate();
  632.                 if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  633.                     gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  634.                     busta.setOraRegistrazione(gdo);
  635.                 }
  636.                 
  637.                 // Traccia
  638.                 Traccia traccia = this.getTraccia(busta, msg, securityInfo, esito, gdo, RuoloMessaggio.RISPOSTA, location, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta);
  639.                 
  640.                 try{
  641.                                 
  642.                     // Miglioramento performance
  643.                     if(OpenSPCoop2Logger.loggerTracciamentoAbilitato){
  644.                         xml = this.xmlBuilder.toString(traccia,TipoSerializzazione.DEFAULT);
  645.                         if(xml==null)
  646.                             throw new Exception("Traccia non costruita");
  647.                         this.loggerTracciamento.info(xml);
  648.                     }
  649.                         
  650.                     // TransazioneContext
  651.                     if(this.openspcoopProperties.isTransazioniSaveTracceInUniqueTransaction()) {
  652.                         this.logTracciaInTransactionContext(traccia, false);
  653.                     }
  654.                     
  655.                     // Tracciamento personalizzato
  656.                     for(int i=0; i<this.loggerTracciamentoOpenSPCoopAppender.size();i++){
  657.                         try{
  658.                             this.loggerTracciamentoOpenSPCoopAppender.get(i).log(getConnectionFromState(false), traccia);
  659.                         }catch(Exception e){
  660.                             logError("Errore durante il tracciamento personalizzato ["+this.tipoTracciamentoOpenSPCoopAppender.get(i)+"] della risposta: "+e.getMessage()+". Traccia non registrata:\n"+xml,e);
  661.                             try{
  662.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, RuoloMessaggio.RISPOSTA.toString());
  663.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA, xml);
  664.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_PERSONALIZZATO,this.tipoTracciamentoOpenSPCoopAppender.get(i));
  665.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  666.                                 this.msgDiagErroreTracciamento.logPersonalizzato("registrazioneNonRiuscita.openspcoopAppender");
  667.                             }catch(Exception eMsg){
  668.                                 // ignore
  669.                             }
  670.                             if(this.openspcoopProperties.isTracciaturaFallita_BloccaCooperazioneInCorso()){
  671.                                 erroreAppender = true;
  672.                                 throw e; // Rilancio
  673.                             }
  674.                         }
  675.                     }
  676.                 }catch(Exception e){
  677.                     // check eventuale costruzione dell'xml non fatto per log4j disabilitato.
  678.                     if( (xml==null) && (OpenSPCoop2Logger.loggerTracciamentoAbilitato==false) ){
  679.                         try{
  680.                             xml = this.xmlBuilder.toString(traccia,TipoSerializzazione.DEFAULT);
  681.                         }catch(Exception eBuild){}
  682.                     }
  683.                     if(xml==null){
  684.                         logError("Errore durante la costruzione della traccia: "+e.getMessage(),e);
  685.                     }else{
  686.                         logError("Errore durante il tracciamento della risposta: "+e.getMessage()+". Traccia non registrata:\n"+xml,e);
  687.                         if(!erroreAppender){
  688.                             try{
  689.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, RuoloMessaggio.RISPOSTA.toString());
  690.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA, xml);
  691.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  692.                                 this.msgDiagErroreTracciamento.logPersonalizzato("registrazioneNonRiuscita");
  693.                             }catch(Exception eMsg){}
  694.                         }
  695.                     }
  696.                     gestioneErroreTracciamento(e);
  697.                 }
  698.             }
  699.         }finally {
  700.             if(this.transactionNullable!=null) {
  701.                 this.transactionNullable.getTempiElaborazione().endTracciamentoRisposta();
  702.             }
  703.         }
  704.     }
  705.     /**
  706.      * Il Metodo si occupa di tracciare una busta di risposta.
  707.      *
  708.      * @param busta Busta da registrare
  709.      * @param bustaObject Busta da registrare (per appender personalizzati)
  710.      * 
  711.      */
  712.     @Deprecated
  713.     public void registraRisposta(OpenSPCoop2Message msg,SecurityInfo securityInfo,
  714.             byte[] busta,Busta bustaObject,EsitoElaborazioneMessaggioTracciato esito, String location) throws TracciamentoException {
  715.         registraRisposta(msg,securityInfo,busta,bustaObject,esito, location,null,null);
  716.     }
  717.     @Deprecated
  718.     public void registraRisposta(OpenSPCoop2Message msg,SecurityInfo securityInfo,
  719.             byte[] busta,Busta bustaObject,EsitoElaborazioneMessaggioTracciato esito, String location, 
  720.             String idCorrelazioneApplicativa, String idCorrelazioneApplicativaRisposta) throws TracciamentoException{
  721.         if(this.transactionNullable!=null) {
  722.             this.transactionNullable.getTempiElaborazione().startTracciamentoRisposta();
  723.         }
  724.         try {
  725.             if(this.tracciamentoSupportatoProtocollo && this.getConfigurazionePdDManager().tracciamentoBuste()){
  726.                 String xml = null;
  727.                 boolean erroreAppender = false;
  728.                 
  729.                 // Data
  730.                 Date gdo = DateManager.getDate();
  731.                 if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  732.                     gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  733.                     bustaObject.setOraRegistrazione(gdo);
  734.                 }
  735.                 
  736.                 // Traccia
  737.                 Traccia traccia = this.getTraccia(bustaObject, msg, securityInfo, esito, gdo, RuoloMessaggio.RISPOSTA, location, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta);
  738.                 traccia.setBustaAsByteArray(busta);
  739.                 
  740.                 try{
  741.                                     
  742.                     // Miglioramento performance
  743.                     if(OpenSPCoop2Logger.loggerTracciamentoAbilitato){
  744.                         xml = this.xmlBuilder.toString(traccia,TipoSerializzazione.DEFAULT);
  745.                         if(xml==null)
  746.                             throw new Exception("Traccia non costruita");
  747.                         this.loggerTracciamento.info(xml);
  748.                     }
  749.                     
  750.                     // TransazioneContext
  751.                     if(this.openspcoopProperties.isTransazioniSaveTracceInUniqueTransaction()) {
  752.                         this.logTracciaInTransactionContext(traccia, false);
  753.                     }
  754.                         
  755.                     // Tracciamento personalizzato
  756.                     for(int i=0; i<this.loggerTracciamentoOpenSPCoopAppender.size();i++){
  757.                         try{
  758.                             this.loggerTracciamentoOpenSPCoopAppender.get(i).log(getConnectionFromState(false), traccia);
  759.                         }catch(Exception e){
  760.                             logError("Errore durante il tracciamento personalizzato ["+this.tipoTracciamentoOpenSPCoopAppender.get(i)+"] della risposta: "+e.getMessage()+". Traccia non registrata:\n"+xml,e);
  761.                             try{
  762.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, RuoloMessaggio.RISPOSTA.toString());
  763.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA, xml);
  764.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_PERSONALIZZATO,this.tipoTracciamentoOpenSPCoopAppender.get(i));
  765.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  766.                                 this.msgDiagErroreTracciamento.logPersonalizzato("registrazioneNonRiuscita.openspcoopAppender");
  767.                             }catch(Exception eMsg){
  768.                                 // ignore
  769.                             }
  770.                             if(this.openspcoopProperties.isTracciaturaFallita_BloccaCooperazioneInCorso()){
  771.                                 erroreAppender = true;
  772.                                 throw e; // Rilancio
  773.                             }
  774.                         }
  775.                     }
  776.                 }catch(Exception e){
  777.                     // check eventuale costruzione dell'xml non fatto per log4j disabilitato.
  778.                     if( (xml==null) && (OpenSPCoop2Logger.loggerTracciamentoAbilitato==false) ){
  779.                         try{
  780.                             xml = this.xmlBuilder.toString(traccia,TipoSerializzazione.DEFAULT);
  781.                         }catch(Exception eBuild){}
  782.                     }
  783.                     if(xml==null){
  784.                         logError("Errore durante la costruzione della traccia: "+e.getMessage(),e);
  785.                     }else{
  786.                         logError("Errore durante il tracciamento della risposta: "+e.getMessage()+". Traccia non registrata:\n"+xml,e);
  787.                         if(!erroreAppender){
  788.                             try{
  789.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, RuoloMessaggio.RISPOSTA.toString());
  790.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA, xml);
  791.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  792.                                 this.msgDiagErroreTracciamento.logPersonalizzato("registrazioneNonRiuscita");
  793.                             }catch(Exception eMsg){}
  794.                         }
  795.                     }
  796.                     gestioneErroreTracciamento(e);
  797.                 }
  798.             }
  799.         }finally {
  800.             if(this.transactionNullable!=null) {
  801.                 this.transactionNullable.getTempiElaborazione().endTracciamentoRisposta();
  802.             }
  803.         }
  804.     }
  805.     /**
  806.      * Il Metodo si occupa di tracciare una busta di risposta.
  807.      *
  808.      * @param busta Busta da registrare
  809.      * @param bustaObject Busta da registrare (per appender personalizzati)
  810.      * 
  811.      */
  812.     public void registraRisposta(OpenSPCoop2Message msg,SecurityInfo securityInfo,
  813.             BustaRawContent<?> busta,Busta bustaObject,EsitoElaborazioneMessaggioTracciato esito, String location) throws TracciamentoException {
  814.         registraRisposta(msg,securityInfo,busta,bustaObject,esito, location,null,null);
  815.     }
  816.     public void registraRisposta(OpenSPCoop2Message msg,SecurityInfo securityInfo,
  817.             BustaRawContent<?> busta,Busta bustaObject,EsitoElaborazioneMessaggioTracciato esito, String location, 
  818.             String idCorrelazioneApplicativa, String idCorrelazioneApplicativaRisposta) throws TracciamentoException {
  819.         if(this.transactionNullable!=null) {
  820.             this.transactionNullable.getTempiElaborazione().startTracciamentoRisposta();
  821.         }
  822.         try {
  823.             if(this.tracciamentoSupportatoProtocollo && this.getConfigurazionePdDManager().tracciamentoBuste()){
  824.                 String xml = null;
  825.                 boolean erroreAppender = false;
  826.                 
  827.                 // Data
  828.                 Date gdo = DateManager.getDate();
  829.                 if(this.openspcoopProperties.generazioneDateCasualiLogAbilitato() && this.pddContext!=null && this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  830.                     gdo = this.generatoreDateCasuali.getProssimaData((String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  831.                     bustaObject.setOraRegistrazione(gdo);
  832.                 }
  833.                 
  834.                 // Traccia
  835.                 Traccia traccia = this.getTraccia(bustaObject, msg, securityInfo, esito, gdo, RuoloMessaggio.RISPOSTA, location, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta);
  836.                 boolean saveHeader = true;
  837.                 try {
  838.                     saveHeader = (this.protocolFactory==null || this.protocolFactory.createProtocolConfiguration().isAbilitatoSalvataggioHeaderProtocolloTracce());
  839.                 }catch(Throwable e) {
  840.                     this.logError("Comprensione opzione 'salvataggio header protocollo tracce' fallita: "+e.getMessage(), new Exception(e));
  841.                 }
  842.                 if(saveHeader) {
  843.                     traccia.setBustaAsRawContent(busta);
  844.                 }
  845.                 
  846.                 try{
  847.                 
  848.                     // Miglioramento performance
  849.                     if(OpenSPCoop2Logger.loggerTracciamentoAbilitato){
  850.                         xml = this.xmlBuilder.toString(traccia,TipoSerializzazione.DEFAULT);
  851.                         if(xml==null)
  852.                             throw new Exception("Traccia non costruita");
  853.                         this.loggerTracciamento.info(xml);
  854.                     }
  855.                     
  856.                     // TransazioneContext
  857.                     if(this.openspcoopProperties.isTransazioniSaveTracceInUniqueTransaction()) {
  858.                         this.logTracciaInTransactionContext(traccia, false);
  859.                     }
  860.                     
  861.                     // Tracciamento personalizzato
  862.                     for(int i=0; i<this.loggerTracciamentoOpenSPCoopAppender.size();i++){
  863.                         try{
  864.                             this.loggerTracciamentoOpenSPCoopAppender.get(i).log(getConnectionFromState(false), traccia);
  865.                         }catch(Exception e){
  866.                             logError("Errore durante il tracciamento personalizzato ["+this.tipoTracciamentoOpenSPCoopAppender.get(i)+"] della risposta: "+e.getMessage()+". Traccia non registrata:\n"+xml,e);
  867.                             try{
  868.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, RuoloMessaggio.RISPOSTA.toString());
  869.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA, xml);
  870.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_PERSONALIZZATO,this.tipoTracciamentoOpenSPCoopAppender.get(i));
  871.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  872.                                 this.msgDiagErroreTracciamento.logPersonalizzato("registrazioneNonRiuscita.openspcoopAppender");
  873.                             }catch(Exception eMsg){
  874.                                 // ignore
  875.                             }
  876.                             if(this.openspcoopProperties.isTracciaturaFallita_BloccaCooperazioneInCorso()){
  877.                                 erroreAppender = true;
  878.                                 throw e; // Rilancio
  879.                             }
  880.                         }
  881.                     }
  882.                 }catch(Exception e){
  883.                     // check eventuale costruzione dell'xml non fatto per log4j disabilitato.
  884.                     if( (xml==null) && (OpenSPCoop2Logger.loggerTracciamentoAbilitato==false) ){
  885.                         try{
  886.                             xml = this.xmlBuilder.toString(traccia,TipoSerializzazione.DEFAULT);
  887.                         }catch(Exception eBuild){}
  888.                     }
  889.                     if(xml==null){
  890.                         logError("Errore durante la costruzione della traccia: "+e.getMessage(),e);
  891.                     }else{
  892.                         logError("Errore durante il tracciamento della risposta: "+e.getMessage()+". Traccia non registrata:\n"+xml,e);
  893.                         if(!erroreAppender){
  894.                             try{
  895.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, RuoloMessaggio.RISPOSTA.toString());
  896.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIA, xml);
  897.                                 this.msgDiagErroreTracciamento.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  898.                                 this.msgDiagErroreTracciamento.logPersonalizzato("registrazioneNonRiuscita");
  899.                             }catch(Exception eMsg){}
  900.                         }
  901.                     }
  902.                     gestioneErroreTracciamento(e);
  903.                 }
  904.             }
  905.         }finally {
  906.             if(this.transactionNullable!=null) {
  907.                 this.transactionNullable.getTempiElaborazione().endTracciamentoRisposta();
  908.             }
  909.         }
  910.     }
  911.     

  913.     private void logTracciaInTransactionContext(Traccia traccia, boolean richiesta) throws TracciamentoException {
  914.         Exception exc = null;
  915.         boolean gestioneStateful = false;
  916.         try {
  917.             Transaction tr = TransactionContext.getTransaction(traccia.getIdTransazione());
  918.             if(richiesta) {
  919.                 tr.setTracciaRichiesta(traccia);
  920.             }
  921.             else {
  922.                 tr.setTracciaRisposta(traccia);
  923.             }
  924.         }catch(TransactionDeletedException e){
  925.             gestioneStateful = true;
  926.         }catch(TransactionNotExistsException e){
  927.             gestioneStateful = true;
  928.         }catch(Exception e){
  929.             exc = e;
  930.         }
  931.         if(gestioneStateful){
  932.             try{
  933.                 //System.out.println("@@@@@REPOSITORY@@@@@ LOG MSG DIAG ID TRANSAZIONE ["+idTransazione+"] ADD");
  934.                 RepositoryGestioneStateful.addTraccia(traccia.getIdTransazione(), traccia);
  935.             }catch(Exception e){
  936.                 exc = e;
  937.             }
  938.         }
  939.         if(exc!=null) {
  940.             logError("Errore durante l'emissione della traccia nel contesto della transazione: "+exc.getMessage(),exc);
  941.             gestioneErroreTracciamento(exc);
  942.         }
  943.     }
  944.     
  945.     
  946.     private Traccia getTraccia(Busta busta,OpenSPCoop2Message msg,SecurityInfo securityInfo,EsitoElaborazioneMessaggioTracciato esito,Date gdo,RuoloMessaggio tipoTraccia,
  947.             String location,String idCorrelazioneApplicativa){
  948.         return getTraccia(busta, msg, securityInfo, esito, gdo, tipoTraccia, location, idCorrelazioneApplicativa, null);
  949.     }
  950.     private Traccia getTraccia(Busta busta,OpenSPCoop2Message msg,SecurityInfo securityInfo,EsitoElaborazioneMessaggioTracciato esito,Date gdo,RuoloMessaggio tipoTraccia,
  951.             String location,String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta){
  952.         
  953.         Traccia traccia = new Traccia();
  954.         
  955.         if(this.pddContext!=null) {
  956.             traccia.setIdTransazione((String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  957.         }
  958.         
  959.         // Esito
  960.         traccia.setEsitoElaborazioneMessaggioTracciato(esito);
  961.         try{
  962.             if(RuoloMessaggio.RISPOSTA.equals(tipoTraccia) && msg!=null){
  963.                 boolean found = false;
  964.                 if(ServiceBinding.SOAP.equals(msg.getServiceBinding())){
  965.                     if(msg.castAsSoap().hasSOAPFault()){
  966.                         SOAPBody body = msg.castAsSoap().getSOAPBody();
  967.                         found = true;
  968.                         StringBuilder bf = new StringBuilder();
  969.                         if(esito.getDettaglio()!=null){
  970.                             bf.append(esito.getDettaglio());
  971.                             bf.append("\n");
  972.                         }
  973.                         bf.append(SoapUtils.safe_toString(msg.getFactory(), body.getFault(), OpenSPCoop2Logger.loggerOpenSPCoopCore));
  974.                         traccia.getEsitoElaborazioneMessaggioTracciato().setDettaglio(bf.toString());
  975.                     }
  976.                 }
  977.                 else {
  978.                     if(msg.castAsRest().isProblemDetailsForHttpApis_RFC7807()) {
  979.                         found = true;
  980.                         ByteArrayOutputStream bout = new ByteArrayOutputStream();
  981.                         msg.writeTo(bout, false);
  982.                         bout.flush();
  983.                         bout.close();
  984.                         StringBuilder bf = new StringBuilder();
  985.                         if(esito.getDettaglio()!=null){
  986.                             bf.append(esito.getDettaglio());
  987.                             bf.append("\n");
  988.                         }
  989.                         bf.append(bout.toString());
  990.                         traccia.getEsitoElaborazioneMessaggioTracciato().setDettaglio(bf.toString());
  991.                     }
  992.                 }

  994.                 if(!found && MessageRole.FAULT.equals(msg.getMessageRole())){
  995.                     ByteArrayOutputStream bout = new ByteArrayOutputStream();
  996.                     msg.writeTo(bout, false);
  997.                     bout.flush();
  998.                     bout.close();
  999.                     StringBuilder bf = new StringBuilder();
  1000.                     if(esito.getDettaglio()!=null){
  1001.                         bf.append(esito.getDettaglio());
  1002.                         bf.append("\n");
  1003.                     }
  1004.                     bf.append(bout.toString());
  1005.                     traccia.getEsitoElaborazioneMessaggioTracciato().setDettaglio(bf.toString());
  1006.                 }
  1007.             }
  1008.         }catch(Exception e){
  1009.             this.logError("errore durante la registrazione del SOAPFault nelle tracce", e);
  1010.         }
  1011.         
  1012.         traccia.setGdo(gdo);
  1013.         traccia.setIdSoggetto(this.idSoggettoDominio);
  1014.         traccia.setTipoMessaggio(tipoTraccia);
  1015.         traccia.setTipoPdD(this.tipoPdD);
  1016.                 
  1017.         traccia.setCorrelazioneApplicativa(idCorrelazioneApplicativa);
  1018.         traccia.setCorrelazioneApplicativaRisposta(idCorrelazioneApplicativaRisposta);
  1019.         if(location!=null) {
  1020.             if(location.length()>230) { // sto piu' basso di 255 per evitare caratteri strani che occupano più bytes.
  1021.                 traccia.setLocation(location.substring(0, 230)+" ...");
  1022.             }
  1023.             else {
  1024.                 traccia.setLocation(location);
  1025.             }
  1026.         }
  1027.         traccia.setProtocollo(this.protocolFactory.getProtocol());
  1028.         
  1029.         if(securityInfo!=null){
  1030.             busta.setDigest(securityInfo.getDigestHeader());
  1031.             Map<String, String> properties = securityInfo.getProperties();
  1032.             if(properties!=null && !properties.isEmpty()) {
  1033.                 for (String key : properties.keySet()) {
  1034.                     busta.addProperty(key, properties.get(key)); // aggiungo le proprieta' di sicurezza riscontrate
  1035.                 }
  1036.             }
  1037.         }
  1038.         traccia.setBusta(busta);
  1039.         
  1040.         if(msg!=null){
  1041.             try{
  1042.                 if(ServiceBinding.SOAP.equals(msg.getServiceBinding())){
  1043.                     // per motivi di streaming, se non e' costruito non lo tracciamo
  1044.                     if(msg.isContentBuilded() && msg.castAsSoap().hasAttachments()) {
  1045.                         java.util.Iterator<?> it = msg.castAsSoap().getAttachments();
  1046.                         while(it.hasNext()){
  1047.                             AttachmentPart ap = 
  1048.                                 (AttachmentPart) it.next();
  1049.                             Allegato allegato = new Allegato();
  1050.                             allegato.setContentId(ap.getContentId());
  1051.                             allegato.setContentLocation(ap.getContentLocation());
  1052.                             allegato.setContentType(ap.getContentType());
  1053.                             
  1054.                             if(securityInfo!=null && ap.getContentId()!=null){
  1055.                                 for (int i = 0; i < securityInfo.sizeListaAllegati(); i++) {
  1056.                                     Allegato a = securityInfo.getAllegato(i);
  1057.                                     if(a.getContentId()!=null && a.getContentId().equals(ap.getContentId())){
  1058.                                         allegato.setDigest(a.getDigest());
  1059.                                     }
  1060.                                 }
  1061.                             }
  1062.                             
  1063.                             traccia.addAllegato(allegato);
  1064.                         }
  1065.                     }
  1066.                 }
  1067.                 else if(MessageType.MIME_MULTIPART.equals(msg.getMessageType())){
  1068.                     // per motivi di streaming, se non e' costruito non lo tracciamo
  1069.                     if(msg.isContentBuilded()){
  1070.                         MultipartContent mc = msg.castAsRestMimeMultipart().getContent();
  1071.                         if(mc!=null) {
  1072.                             MimeMultipart mime = mc.getMimeMultipart();
  1073.                             if(mime!=null) {
  1074.                                 for (int i = 0; i < mime.countBodyParts(); i++) {
  1075.                                     BodyPart bodyPart = mime.getBodyPart(i);
  1076.                                     String contentId = mime.getContentID(bodyPart);
  1077.                                     if(contentId==null){
  1078.                                         // provo a vedere se c'e' un disposition
  1079.                                         contentId = mime.getContentDisposition(bodyPart);
  1080.                                     }
  1081.                                     
  1082.                                     Allegato allegato = new Allegato();
  1083.                                     allegato.setContentId(contentId);
  1084.                                     allegato.setContentLocation(mime.getContentLocation(bodyPart));
  1085.                                     allegato.setContentType(bodyPart.getContentType());
  1086.                                     
  1087.                                     if(securityInfo!=null && contentId!=null){
  1088.                                         for (int j = 0; j < securityInfo.sizeListaAllegati(); j++) {
  1089.                                             Allegato a = securityInfo.getAllegato(j);
  1090.                                             if(a.getContentId()!=null && a.getContentId().equals(contentId)){
  1091.                                                 allegato.setDigest(a.getDigest());
  1092.                                             }
  1093.                                         }
  1094.                                     }
  1095.                                     
  1096.                                     traccia.addAllegato(allegato);
  1097.                                 }
  1098.                             }
  1099.                         }
  1100.                     }
  1101.                 }
  1102.             }catch(Exception e){
  1103.                 this.logError("errore durante la registrazione degli allegati nelle tracce", e);
  1104.             }
  1105.         }
  1106.         
  1107.         if(this.pddContext!=null){
  1108.             List<MapKey<String>> keys = org.openspcoop2.core.constants.Costanti.CONTEXT_OBJECT;
  1109.             if(keys!=null){
  1110.                 for (int j = 0; j < keys.size(); j++) {
  1111.                     MapKey<String> mapKey = keys.get(j);
  1112.                     Object o = this.pddContext.getObject(mapKey);
  1113.                     if(o!=null && o instanceof String){
  1114.                         traccia.addProperty(mapKey.getValue(), (String)o);
  1115.                     }
  1116.                 }
  1117.             }
  1118.         }
  1119.         
  1120.         return traccia;
  1121.     }
  1122.     
  1123.     private void gestioneErroreTracciamento(Exception e) throws TracciamentoException{
  1124.         
  1125.         if(this.openspcoopProperties.isTracciaturaFallita_BloccoServiziPdD()){
  1126.             Tracciamento.tracciamentoDisponibile=false;
  1127.             Tracciamento.motivoMalfunzionamentoTracciamento=e;
  1128.             try{
  1129.                 this.msgDiagErroreTracciamento.logPersonalizzato("errore.bloccoServizi");
  1130.             }catch(Exception eMsg){
  1131.                 // ignore
  1132.             }
  1133.             logError("Il Sistema di tracciamento ha rilevato un errore durante la registrazione di una traccia legale,"+
  1134.                     " tutti i servizi/moduli della porta di dominio sono sospesi. Si richiede un intervento sistemistico per la risoluzione del problema "+
  1135.                     "e il riavvio di GovWay. Errore rilevato: ",e);
  1136.         }
  1137.         
  1138.         if(this.openspcoopProperties.isTracciaturaFallita_BloccaCooperazioneInCorso()){
  1139.             throw new TracciamentoException(e);
  1140.         }
  1141.     }
  1142.     
  1143.     
  1144.     private void logError(String msgErrore,Exception e){
  1145.         if(OpenSPCoop2Logger.loggerOpenSPCoopCore!=null){
  1146.             OpenSPCoop2Logger.loggerOpenSPCoopCore.error(msgErrore,e);
  1147.         }
  1148.         
  1149.         // Registro l'errore anche in questo logger.
  1150.         if(OpenSPCoop2Logger.loggerOpenSPCoopResources!=null){
  1151.             OpenSPCoop2Logger.loggerOpenSPCoopResources.error(msgErrore,e);
  1152.         }
  1153.         
  1154.     }
  1155.     @SuppressWarnings("unused")
  1156.     private void logError(String msgErrore){
  1157.         if(OpenSPCoop2Logger.loggerOpenSPCoopCore!=null){
  1158.             OpenSPCoop2Logger.loggerOpenSPCoopCore.error(msgErrore);
  1159.         }
  1160.         
  1161.         // Registro l'errore anche in questo logger.
  1162.         if(OpenSPCoop2Logger.loggerOpenSPCoopResources!=null){
  1163.             OpenSPCoop2Logger.loggerOpenSPCoopResources.error(msgErrore);
  1164.         }
  1165.         
  1166.     }
  1167.     
  1168. }
Created with JaCoCo 0.8.8.202204050719