Dump.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.sql.Connection;
  27. import java.util.Date;
  28. import java.util.HashMap;
  29. import java.util.Iterator;
  30. import java.util.List;
  31. import java.util.Map;

  33. import org.openspcoop2.core.config.DumpConfigurazione;
  34. import org.openspcoop2.core.config.PortaApplicativa;
  35. import org.openspcoop2.core.config.PortaDelegata;
  36. import org.openspcoop2.core.config.Proprieta;
  37. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  38. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  39. import org.openspcoop2.core.constants.TipoPdD;
  40. import org.openspcoop2.core.id.IDPortaApplicativa;
  41. import org.openspcoop2.core.id.IDPortaDelegata;
  42. import org.openspcoop2.core.id.IDServizio;
  43. import org.openspcoop2.core.id.IDSoggetto;
  44. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  45. import org.openspcoop2.core.transazioni.TransazioneApplicativoServer;
  46. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  47. import org.openspcoop2.message.OpenSPCoop2Message;
  48. import org.openspcoop2.message.OpenSPCoop2MessageProperties;
  49. import org.openspcoop2.message.constants.MessageType;
  50. import org.openspcoop2.message.constants.ServiceBinding;
  51. import org.openspcoop2.message.exception.MessageException;
  52. import org.openspcoop2.message.rest.DumpRestMessageUtils;
  53. import org.openspcoop2.message.soap.DumpSoapMessageUtils;
  54. import org.openspcoop2.message.utils.DumpAttachment;
  55. import org.openspcoop2.message.utils.DumpMessaggio;
  56. import org.openspcoop2.message.utils.DumpMessaggioConfig;
  57. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  58. import org.openspcoop2.pdd.config.CostantiProprieta;
  59. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  60. import org.openspcoop2.pdd.core.CostantiPdD;
  61. import org.openspcoop2.pdd.core.PdDContext;
  62. import org.openspcoop2.pdd.core.connettori.InfoConnettoreUscita;
  63. import org.openspcoop2.pdd.core.transazioni.GestoreConsegnaMultipla;
  64. import org.openspcoop2.pdd.core.transazioni.RepositoryGestioneStateful;
  65. import org.openspcoop2.pdd.core.transazioni.Transaction;
  66. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  67. import org.openspcoop2.pdd.core.transazioni.TransactionDeletedException;
  68. import org.openspcoop2.pdd.core.transazioni.TransactionNotExistsException;
  69. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  70. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  71. import org.openspcoop2.protocol.sdk.dump.Attachment;
  72. import org.openspcoop2.protocol.sdk.dump.BodyMultipartInfo;
  73. import org.openspcoop2.protocol.sdk.dump.DumpException;
  74. import org.openspcoop2.protocol.sdk.dump.IDumpProducer;
  75. import org.openspcoop2.protocol.sdk.dump.Messaggio;
  76. import org.openspcoop2.protocol.sdk.state.IState;
  77. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  78. import org.openspcoop2.protocol.sdk.state.StateMessage;
  79. import org.openspcoop2.protocol.sdk.state.URLProtocolContext;
  80. import org.openspcoop2.protocol.sdk.tracciamento.TracciamentoException;
  81. import org.openspcoop2.utils.date.DateManager;
  82. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  83. import org.openspcoop2.utils.transport.TransportUtils;
  84. import org.openspcoop2.utils.transport.http.HttpConstants;
  85. import org.slf4j.Logger;



  89. /**
  90.  * Contiene la definizione un Logger utilizzato dai nodi dell'infrastruttura di OpenSPCoop
  91.  * per la registrazione di messaggi diagnostici.
  92.  *
  93.  * @author Poli Andrea (apoli@link.it)
  94.  * @author $Author$
  95.  * @version $Rev$, $Date$
  96.  */

  98. public class Dump {

  100.     /** Indicazione di un dump funzionante */
  101.     private static boolean sistemaDumpDisponibile = true;
  102.     public static boolean isSistemaDumpDisponibile() {
  103.         return sistemaDumpDisponibile;
  104.     }
  105.     public static void setSistemaDumpDisponibile(boolean sistemaDumpDisponibile) {
  106.         Dump.sistemaDumpDisponibile = sistemaDumpDisponibile;
  107.     }

  109.     /** Primo errore avvenuto nel momento in cui รจ stato rilevato un malfunzionamento nel sistema di dump */
  110.     private static Throwable motivoMalfunzionamentoDump = null;
  111.     public static Throwable getMotivoMalfunzionamentoDump() {
  112.         return motivoMalfunzionamentoDump;
  113.     }
  114.     public static void setMotivoMalfunzionamentoDump(Throwable motivoMalfunzionamentoDump) {
  115.         Dump.motivoMalfunzionamentoDump = motivoMalfunzionamentoDump;
  116.     }
  117.     
  118.     private static final String DIAGNOSTICO_REGISTRAZIONE_NON_RIUSCITA = "dumpContenutiApplicativi.registrazioneNonRiuscita";
  119.     

  121.     /**  Logger log4j utilizzato per effettuare un dump dei messaggi applicativi */
  122.     private Logger loggerDump = null;
  123.     private void loggerDumpError(String msg) {
  124.         if(this.loggerDump!=null) {
  125.             this.loggerDump.error(msg);
  126.         }
  127.     }
  128.     private void loggerDumpError(String msg, Throwable e) {
  129.         if(this.loggerDump!=null) {
  130.             this.loggerDump.error(msg,e);
  131.         }
  132.     }
  133.     
  134.     private void loggerOpenSPCoopResourcesError(String msg, Throwable e) {
  135.         if(OpenSPCoop2Logger.loggerOpenSPCoopResources!=null) {
  136.             OpenSPCoop2Logger.loggerOpenSPCoopResources.error(msg,e);
  137.         }
  138.     }
  139.     
  140.     
  141.     
  142.     /** Soggetto che richiede il logger */
  143.     private IDSoggetto dominio;
  144.     /** Modulo Funzionale */
  145.     private String idModulo;
  146.     /** Identificativo del Messaggio */
  147.     private String idMessaggio;
  148.     /** Fruitore */
  149.     private IDSoggetto fruitore;
  150.     /** Servizio */
  151.     private IDServizio servizio;
  152.     /** Signature */
  153.     private String signature;
  154.     /** GDO */
  155.     private Date gdo;
  156.     /** TipoPdD */
  157.     private TipoPdD tipoPdD;
  158.     private String nomePorta;
  159.     /** PdDContext */
  160.     private PdDContext pddContext;
  161.     /** RequestInfo */
  162.     private RequestInfo requestInfo = null;
  163.     
  164.     /** OpenSPCoopProperties */
  165.     private OpenSPCoop2Properties properties = null;

  167.     /** MsgDiagnostico per eventuali errori di tracciamento (viene usato anche per registrare il dump in corso e completato) */
  168.     private MsgDiagnostico msgDiagErroreDump = null;
  169.     private boolean emitDiagnosticDump = false;
  170.     
  171.     /** Appender personalizzati per i dump applicativi di OpenSPCoop */
  172.     private List<IDumpProducer> loggerDumpOpenSPCoopAppender = null; 
  173.     private List<String> tipoDumpOpenSPCoopAppender = null; 
  174.     
  175.     private DumpConfigurazione dumpConfigurazione;
  176.     
  177.     private IProtocolFactory<?> protocolFactory = null;
  178.     private String idTransazione = null;
  179.     
  180.     /** Stati */
  181.     private StateMessage statoRichiesta;
  182.     private StateMessage statoRisposta;
  183.     
  184.     /** Transaction */
  185.     private Transaction transactionNullable = null;
  186.     
  187.     /** -----------------Impostazione TransazioneApplicativoServer ---------------- */
  188.     private TransazioneApplicativoServer transazioneApplicativoServer;
  189.     private IDPortaApplicativa idPortaApplicativa;
  190.     private Date dataConsegnaTransazioneApplicativoServer;
  191.     public void setTransazioneApplicativoServer(TransazioneApplicativoServer transazioneApplicativoServer, IDPortaApplicativa idPortaApplicativa, Date dataConsegnaTransazioneApplicativoServer) {
  192.         this.transazioneApplicativoServer = transazioneApplicativoServer;
  193.         this.idPortaApplicativa = idPortaApplicativa;
  194.         this.dataConsegnaTransazioneApplicativoServer = dataConsegnaTransazioneApplicativoServer;
  195.     }
  196.     
  197.     /**
  198.      * Costruttore. 
  199.      *
  200.      * @param dominio Soggetto che richiede il logger
  201.      * @param modulo Funzione che richiede il logger
  202.      * @param pddContext pddContext
  203.      * 
  204.      */
  205.     public Dump(IDSoggetto dominio, String modulo, TipoPdD tipoPdD, String nomePorta, PdDContext pddContext, DumpConfigurazione dumpConfigurazione) throws DumpException{ // dump binario
  206.         this(dominio, modulo, null, null, null, tipoPdD, nomePorta, pddContext,null,null,dumpConfigurazione);
  207.     }
  208.     public Dump(IDSoggetto dominio, String modulo, TipoPdD tipoPdD, String nomePorta, PdDContext pddContext,IState statoRichiesta,IState statoRisposta,
  209.             DumpConfigurazione dumpConfigurazione) throws DumpException{
  210.         this(dominio, modulo, null, null, null, tipoPdD, nomePorta, pddContext,statoRichiesta,statoRisposta,dumpConfigurazione);
  211.     }
  212.     public Dump(IDSoggetto dominio, String modulo, String idMessaggio, IDSoggetto fruitore, IDServizio servizio, 
  213.             TipoPdD tipoPdD, String nomePorta, PdDContext pddContext,IState stateParam,IState responseStateParam,
  214.             DumpConfigurazione dumpConfigurazione) throws DumpException{
  215.         this.dominio = dominio;
  216.         this.idModulo = modulo;
  217.         this.idMessaggio = idMessaggio;
  218.         this.fruitore = fruitore;
  219.         this.servizio = servizio;
  220.         this.loggerDump = OpenSPCoop2Logger.loggerDump;
  221.         this.loggerDumpOpenSPCoopAppender = OpenSPCoop2Logger.loggerDumpOpenSPCoopAppender;
  222.         this.tipoDumpOpenSPCoopAppender = OpenSPCoop2Logger.tipoDumpOpenSPCoopAppender;
  223.         this.gdo = DateManager.getDate();
  224.         if(this.dominio!=null)
  225.             this.signature = this.dominio.getCodicePorta()+" <"+this.gdo+"> "+this.idModulo+"\n";
  226.         else
  227.             this.signature = "<"+this.gdo+"> "+this.idModulo+"\n";
  228.         this.tipoPdD = tipoPdD;
  229.         this.nomePorta = nomePorta;
  230.         this.pddContext = pddContext;
  231.         if(this.pddContext==null) {
  232.             throw new DumpException("PdDContext is null");
  233.         }
  234.         
  235.         this.properties = OpenSPCoop2Properties.getInstance();
  236.         if(stateParam instanceof StateMessage){
  237.             this.statoRichiesta = (StateMessage) stateParam;
  238.         }
  239.         if(responseStateParam instanceof StateMessage){
  240.             this.statoRisposta = (StateMessage) responseStateParam;
  241.         }
  242.         
  243.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  244.         
  245.         this.dumpConfigurazione = dumpConfigurazione;
  246.         
  247.         if(this.pddContext.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  248.             this.requestInfo = (RequestInfo) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  249.         }
  250.         
  251.         this.msgDiagErroreDump = MsgDiagnostico.newInstance(this.tipoPdD,dominio,modulo,nomePorta,this.requestInfo,this.statoRichiesta,this.statoRisposta);
  252.         this.msgDiagErroreDump.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TRACCIAMENTO);
  253.         this.emitDiagnosticDump = op2Properties.isDumpEmitDiagnostic();
  254.         
  255.         this.idTransazione = (String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  256.         
  257.         // Protocol Factory Manager
  258.         String protocol = null;
  259.         try{
  260.             this.protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName((String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  261.             protocol = this.protocolFactory.getProtocol();
  262.             this.msgDiagErroreDump.setPddContext(this.pddContext, this.protocolFactory);
  263.         }catch (Exception e) {
  264.             throw new DumpException("Errore durante l'inizializzazione del ProtocolFactoryManager...",e);
  265.         }
  266.         if(this.dominio==null){
  267.             this.dominio=op2Properties.getIdentitaPortaDefault(protocol, this.requestInfo);
  268.         }
  269.         
  270.         try{
  271.             if(this.idTransazione!=null) {
  272.                 this.transactionNullable = TransactionContext.getTransaction(this.idTransazione);
  273.             }
  274.         }catch(Exception e){
  275.             // La transazione potrebbe essere stata eliminata nelle comunicazioni stateful
  276.         }
  277.     }
  278.     
  279.     private Connection getConnectionFromState(boolean richiesta){
  280.         if(richiesta){
  281.             Connection c = StateMessage.getConnection(this.statoRichiesta);
  282.             if(c!=null) {
  283.                 return c;
  284.             }
  285.         }
  286.         else{
  287.             Connection c = StateMessage.getConnection(this.statoRisposta);
  288.             if(c!=null) {
  289.                 return c;
  290.             }
  291.         }
  292.         return null;
  293.     }






  300.     /** ----------------- METODI DI LOGGING  ---------------- */
  301.     public void emitDiagnosticStartDumpBinarioRichiestaIngresso(boolean onlyFileTrace) {
  302.         emitDiagnosticDumpStart(TipoMessaggio.RICHIESTA_INGRESSO_DUMP_BINARIO, onlyFileTrace);
  303.     }
  304.     public void dumpBinarioRichiestaIngresso(boolean dumpBinarioRegistrazioneDatabase, boolean onlyLogFileTraceHeaders, boolean onlyLogFileTraceBody, 
  305.             DumpByteArrayOutputStream msg, MessageType messageType, 
  306.             URLProtocolContext protocolContext) throws DumpException {
  307.         if(this.transactionNullable!=null) {
  308.             this.transactionNullable.getTempiElaborazione().startDumpBinarioRichiestaIngresso();
  309.         }
  310.         try {
  311.             dump(dumpBinarioRegistrazioneDatabase, onlyLogFileTraceHeaders, onlyLogFileTraceBody, TipoMessaggio.RICHIESTA_INGRESSO_DUMP_BINARIO,
  312.                     null,msg,messageType,
  313.                     protocolContext!=null ? protocolContext.getSource() : null,
  314.                     protocolContext!=null ? protocolContext.getHeaders() : null);
  315.         }
  316.         finally {
  317.             if(this.transactionNullable!=null) {
  318.                 this.transactionNullable.getTempiElaborazione().endDumpBinarioRichiestaIngresso();
  319.             }
  320.         }
  321.     }
  322.     
  323.     public void dumpRichiestaIngresso(OpenSPCoop2Message msg, URLProtocolContext protocolContext) throws DumpException {
  324.         if(this.transactionNullable!=null) {
  325.             this.transactionNullable.getTempiElaborazione().startDumpRichiestaIngresso();
  326.         }
  327.         try {
  328.             dump(false, false, false, TipoMessaggio.RICHIESTA_INGRESSO,
  329.                     msg,null,null,
  330.                     protocolContext!=null ? protocolContext.getSource() : null,
  331.                     protocolContext!=null ? protocolContext.getHeaders() : null);
  332.         }
  333.         finally {
  334.             if(this.transactionNullable!=null) {
  335.                 this.transactionNullable.getTempiElaborazione().endDumpRichiestaIngresso();
  336.             }
  337.         }
  338.     }
  339.     public void dumpRichiestaIngressoByIntegrationManagerError(byte[] msg, URLProtocolContext protocolContext) throws DumpException {
  340.         if(this.transactionNullable!=null) {
  341.             this.transactionNullable.getTempiElaborazione().startDumpRichiestaIngresso();
  342.         }
  343.         try {
  344.             dump(false, false, false, TipoMessaggio.RICHIESTA_INGRESSO,
  345.                     null,DumpByteArrayOutputStream.newInstance(msg),null,
  346.                     protocolContext!=null ? protocolContext.getSource() : null,
  347.                     protocolContext!=null ? protocolContext.getHeaders() : null);
  348.         }
  349.         finally {
  350.             if(this.transactionNullable!=null) {
  351.                 this.transactionNullable.getTempiElaborazione().endDumpRichiestaIngresso();
  352.             }
  353.         }
  354.     }
  355.     
  356.     public void emitDiagnosticStartDumpBinarioRichiestaUscita(boolean onlyFileTrace) {
  357.         emitDiagnosticDumpStart(TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO, onlyFileTrace);
  358.     }
  359.     public void dumpBinarioRichiestaUscita(boolean dumpBinarioRegistrazioneDatabase, boolean onlyLogFileTraceHeaders, boolean onlyLogFileTraceBody, 
  360.             DumpByteArrayOutputStream msg, MessageType messageType, 
  361.             InfoConnettoreUscita infoConnettore) throws DumpException {
  362.         if(this.transactionNullable!=null) {
  363.             this.transactionNullable.getTempiElaborazione().startDumpBinarioRichiestaUscita();
  364.         }
  365.         try {
  366.             dump(dumpBinarioRegistrazioneDatabase, onlyLogFileTraceHeaders, onlyLogFileTraceBody, TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO,
  367.                     null,msg,messageType,
  368.                     (infoConnettore!=null ? infoConnettore.getLocation() : null),
  369.                     (infoConnettore!=null ? infoConnettore.getHeaders() : null));
  370.         }
  371.         finally {
  372.             if(this.transactionNullable!=null) {
  373.                 this.transactionNullable.getTempiElaborazione().endDumpBinarioRichiestaUscita();
  374.             }
  375.         }
  376.     }
  377.     public void dumpRichiestaUscita(OpenSPCoop2Message msg, InfoConnettoreUscita infoConnettore) throws DumpException {
  378.         if(this.transactionNullable!=null) {
  379.             this.transactionNullable.getTempiElaborazione().startDumpRichiestaUscita();
  380.         }
  381.         try {
  382.             dump(false, false, false, TipoMessaggio.RICHIESTA_USCITA,
  383.                     msg,null,null,
  384.                     (infoConnettore!=null ? infoConnettore.getLocation() : null),
  385.                     (infoConnettore!=null ? infoConnettore.getHeaders() : null));
  386.         }
  387.         finally {
  388.             if(this.transactionNullable!=null) {
  389.                 this.transactionNullable.getTempiElaborazione().endDumpRichiestaUscita();
  390.             }
  391.         }
  392.     }

  394.     public void emitDiagnosticStartDumpBinarioRispostaIngresso(boolean onlyFileTrace) {
  395.         emitDiagnosticDumpStart(TipoMessaggio.RISPOSTA_INGRESSO_DUMP_BINARIO, onlyFileTrace);
  396.     }
  397.     public void dumpBinarioRispostaIngresso(boolean dumpBinarioRegistrazioneDatabase, boolean onlyLogFileTraceHeaders, boolean onlyLogFileTraceBody, 
  398.             DumpByteArrayOutputStream msg, MessageType messageType, 
  399.             InfoConnettoreUscita infoConnettore, Map<String, List<String>> transportHeaderRisposta) throws DumpException {
  400.         if(this.transactionNullable!=null) {
  401.             this.transactionNullable.getTempiElaborazione().startDumpBinarioRispostaIngresso();
  402.         }
  403.         try {
  404.             dump(dumpBinarioRegistrazioneDatabase, onlyLogFileTraceHeaders, onlyLogFileTraceBody, TipoMessaggio.RISPOSTA_INGRESSO_DUMP_BINARIO,
  405.                     null,msg,messageType,
  406.                     (infoConnettore!=null ? infoConnettore.getLocation() : null),transportHeaderRisposta);
  407.         }
  408.         finally {
  409.             if(this.transactionNullable!=null) {
  410.                 this.transactionNullable.getTempiElaborazione().endDumpBinarioRispostaIngresso();
  411.             }
  412.         }
  413.     }
  414.     
  415.     public void dumpRispostaIngresso(OpenSPCoop2Message msg, InfoConnettoreUscita infoConnettore, Map<String, List<String>> transportHeaderRisposta) throws DumpException {
  416.         if(this.transactionNullable!=null) {
  417.             this.transactionNullable.getTempiElaborazione().startDumpRispostaIngresso();
  418.         }
  419.         try {
  420.             dump(false, false, false, TipoMessaggio.RISPOSTA_INGRESSO,
  421.                     msg,null,null,
  422.                     (infoConnettore!=null ? infoConnettore.getLocation() : null),transportHeaderRisposta);
  423.         }
  424.         finally {
  425.             if(this.transactionNullable!=null) {
  426.                 this.transactionNullable.getTempiElaborazione().endDumpRispostaIngresso();
  427.             }
  428.         }
  429.     }
  430.     

  432.     public void emitDiagnosticStartDumpBinarioRispostaUscita(boolean onlyFileTrace) {
  433.         emitDiagnosticDumpStart(TipoMessaggio.RISPOSTA_USCITA_DUMP_BINARIO, onlyFileTrace);
  434.     }
  435.     public void dumpBinarioRispostaUscita(boolean dumpBinarioRegistrazioneDatabase, boolean onlyLogFileTraceHeaders, boolean onlyLogFileTraceBody, 
  436.             DumpByteArrayOutputStream msg, MessageType messageType, 
  437.             URLProtocolContext protocolContext, Map<String, List<String>> transportHeaderRisposta) throws DumpException {
  438.         if(this.transactionNullable!=null) {
  439.             this.transactionNullable.getTempiElaborazione().startDumpBinarioRispostaUscita();
  440.         }
  441.         try {
  442.             dump(dumpBinarioRegistrazioneDatabase, onlyLogFileTraceHeaders, onlyLogFileTraceBody, TipoMessaggio.RISPOSTA_USCITA_DUMP_BINARIO,
  443.                     null,msg,messageType,
  444.                     protocolContext!=null ? protocolContext.getSource() : null,transportHeaderRisposta);
  445.         }
  446.         finally {
  447.             if(this.transactionNullable!=null) {
  448.                 this.transactionNullable.getTempiElaborazione().endDumpBinarioRispostaUscita();
  449.             }
  450.         }
  451.     }
  452.     
  453.     public void dumpRispostaUscita(OpenSPCoop2Message msg, URLProtocolContext protocolContext, Map<String, List<String>> transportHeaderRisposta) throws DumpException {
  454.         if(this.transactionNullable!=null) {
  455.             this.transactionNullable.getTempiElaborazione().startDumpRispostaUscita();
  456.         }
  457.         try {
  458.             dump(false, false, false, TipoMessaggio.RISPOSTA_USCITA,
  459.                     msg,null,null,
  460.                     protocolContext!=null ? protocolContext.getSource() : null,transportHeaderRisposta);
  461.         }
  462.         finally {
  463.             if(this.transactionNullable!=null) {
  464.                 this.transactionNullable.getTempiElaborazione().endDumpRispostaUscita();
  465.             }
  466.         }
  467.     }
  468.     

  470.     public void dumpIntegrationManagerGetMessage(OpenSPCoop2Message msg) throws DumpException {
  471.         if(this.transactionNullable!=null) {
  472.             this.transactionNullable.getTempiElaborazione().startDumpIntegrationManager();
  473.         }
  474.         try {
  475.             dump(false, false, false, TipoMessaggio.INTEGRATION_MANAGER,
  476.                     msg,null,null,
  477.                     "IntegrationManager.getMessage()",null);
  478.         }
  479.         finally {
  480.             if(this.transactionNullable!=null) {
  481.                 this.transactionNullable.getTempiElaborazione().endDumpIntegrationManager();
  482.             }
  483.         }
  484.     }
  485.     
  486.     /**
  487.      * Il Metodo si occupa di creare un effettuare un dump del messaggio applicativo. 
  488.      *
  489.      * @param msg Messaggio da registrare
  490.      * @throws TracciamentoException 
  491.      * 
  492.      */
  493.     private void dump(boolean dumpBinarioRegistrazioneDatabase, boolean onlyLogFileTraceHeaders, boolean onlyLogFileTraceBody, 
  494.             TipoMessaggio tipoMessaggio,OpenSPCoop2Message msg,DumpByteArrayOutputStream msgBytes, MessageType messageType,
  495.             String location,Map<String, List<String>> transportHeaderParam) throws DumpException {

  497.         boolean dumpNormale = TipoMessaggio.RICHIESTA_INGRESSO.equals(tipoMessaggio) ||
  498.                 TipoMessaggio.RICHIESTA_USCITA.equals(tipoMessaggio) ||
  499.                 TipoMessaggio.RISPOSTA_INGRESSO.equals(tipoMessaggio) ||
  500.                 TipoMessaggio.RISPOSTA_USCITA.equals(tipoMessaggio);
  501.         
  502.         boolean dumpBinario = TipoMessaggio.RICHIESTA_INGRESSO_DUMP_BINARIO.equals(tipoMessaggio) ||
  503.                 TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO.equals(tipoMessaggio) ||
  504.                 TipoMessaggio.RISPOSTA_INGRESSO_DUMP_BINARIO.equals(tipoMessaggio) ||
  505.                 TipoMessaggio.RISPOSTA_USCITA_DUMP_BINARIO.equals(tipoMessaggio);
  506.         
  507.         boolean dumpIntegrationManager = TipoMessaggio.INTEGRATION_MANAGER.equals(tipoMessaggio); 
  508.         
  509.         
  510.         if(dumpNormale) {
  511.             if(this.dumpConfigurazione==null) {
  512.                 return; // disabilitato
  513.             }
  514.             if(this.dumpConfigurazione!=null && StatoFunzionalita.DISABILITATO.equals(this.dumpConfigurazione.getRealtime())) {
  515.                 return; // viene gestito tramite l'handler notify
  516.             }
  517.         }
  518.                 
  519.         boolean dumpHeaders = true; 
  520.         boolean dumpBody = true;
  521.         boolean dumpAttachments = true;
  522.         if(dumpBinario) {
  523.             dumpAttachments = false;
  524.         }
  525.         boolean dumpBinarioAttivatoTramiteRegolaConfigurazione = false;
  526.         
  527.         if(dumpNormale) {
  528.             // Il dump non binario si utilizza solo se viene richiesto un payload parsing, altrimenti quello binario รจ piรน preciso (anche se sono abilitati solo gli header) 
  529.             if(TipoMessaggio.RICHIESTA_INGRESSO.equals(tipoMessaggio)) {
  530.                 if(this.dumpConfigurazione!=null && this.dumpConfigurazione.getRichiestaIngresso()!=null) {
  531.                     if(StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaIngresso().getPayload()) &&
  532.                             StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaIngresso().getPayloadParsing())){
  533.                         dumpHeaders = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaIngresso().getHeaders());
  534.                         dumpBody = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaIngresso().getBody());
  535.                         dumpAttachments = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaIngresso().getAttachments());      
  536.                     }
  537.                     else {
  538.                         dumpHeaders = false;
  539.                         dumpBody = false;
  540.                         dumpAttachments = false;
  541.                     }
  542.                 }
  543.             }
  544.             else if(TipoMessaggio.RICHIESTA_USCITA.equals(tipoMessaggio)) {
  545.                 if(this.dumpConfigurazione!=null && this.dumpConfigurazione.getRichiestaUscita()!=null) {
  546.                     if(StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaUscita().getPayload()) &&
  547.                             StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaUscita().getPayloadParsing())){
  548.                         dumpHeaders = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaUscita().getHeaders());
  549.                         dumpBody = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaUscita().getBody());
  550.                         dumpAttachments = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaUscita().getAttachments());
  551.                     }
  552.                     else {
  553.                         dumpHeaders = false;
  554.                         dumpBody = false;
  555.                         dumpAttachments = false;
  556.                     }
  557.                 }
  558.             }
  559.             else if(TipoMessaggio.RISPOSTA_INGRESSO.equals(tipoMessaggio)) {
  560.                 if(this.dumpConfigurazione!=null && this.dumpConfigurazione.getRispostaIngresso()!=null) {
  561.                     if(StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaIngresso().getPayload()) &&
  562.                             StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaIngresso().getPayloadParsing())){
  563.                         dumpHeaders = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaIngresso().getHeaders());
  564.                         dumpBody = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaIngresso().getBody());
  565.                         dumpAttachments = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaIngresso().getAttachments());
  566.                     }
  567.                     else {
  568.                         dumpHeaders = false;
  569.                         dumpBody = false;
  570.                         dumpAttachments = false;
  571.                     }
  572.                 }
  573.             }
  574.             else if(TipoMessaggio.RISPOSTA_USCITA.equals(tipoMessaggio) &&
  575.                 this.dumpConfigurazione!=null && this.dumpConfigurazione.getRispostaUscita()!=null) {
  576.                 if(StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaUscita().getPayload()) &&
  577.                         StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaUscita().getPayloadParsing())){
  578.                     dumpHeaders = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaUscita().getHeaders());
  579.                     dumpBody = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaUscita().getBody());
  580.                     dumpAttachments = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaUscita().getAttachments());
  581.                 }
  582.                 else {
  583.                     dumpHeaders = false;
  584.                     dumpBody = false;
  585.                     dumpAttachments = false;
  586.                 }
  587.             }
  588.             if(!dumpHeaders && !dumpBody && !dumpAttachments) {
  589.                 return; // disabilitato
  590.             }
  591.         }
  592.         else if(dumpBinario) {
  593.             
  594.             if(dumpBinarioRegistrazioneDatabase) {
  595.                 // registro tutto
  596.             }
  597.             else {
  598.                     
  599.                 // imposto a false; verifico poi regola specifica e faccio successivamente verifica per file trace
  600.                 dumpHeaders = false;
  601.                 dumpBody = false;
  602.                 
  603.                 // Il dump non binario si utilizza solo se viene richiesto un payload parsing, altrimenti quello binario รจ piรน preciso (anche se sono abilitati solo gli header) 
  604.                 if(TipoMessaggio.RICHIESTA_INGRESSO_DUMP_BINARIO.equals(tipoMessaggio)) {
  605.                     if(this.dumpConfigurazione!=null && this.dumpConfigurazione.getRichiestaIngresso()!=null) {
  606.                         boolean payloadParsing = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaIngresso().getPayload()) &&
  607.                                 StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaIngresso().getPayloadParsing());
  608.                         if(!payloadParsing) {
  609.                             dumpHeaders = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaIngresso().getHeaders());
  610.                             dumpBody = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaIngresso().getPayload());
  611.                             dumpBinarioAttivatoTramiteRegolaConfigurazione = dumpHeaders || dumpBody;
  612.                         }
  613.                     }
  614.                 }
  615.                 else if(TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO.equals(tipoMessaggio)) {
  616.                     if(this.dumpConfigurazione!=null && this.dumpConfigurazione.getRichiestaUscita()!=null) {
  617.                         boolean payloadParsing = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaUscita().getPayload()) &&
  618.                                 StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaUscita().getPayloadParsing());
  619.                         if(!payloadParsing) {
  620.                             dumpHeaders = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaUscita().getHeaders());
  621.                             dumpBody = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRichiestaUscita().getPayload());
  622.                             dumpBinarioAttivatoTramiteRegolaConfigurazione = dumpHeaders || dumpBody;
  623.                         }
  624.                     }
  625.                 }
  626.                 else if(TipoMessaggio.RISPOSTA_INGRESSO_DUMP_BINARIO.equals(tipoMessaggio)) {
  627.                     if(this.dumpConfigurazione!=null && this.dumpConfigurazione.getRispostaIngresso()!=null) {
  628.                         boolean payloadParsing = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaIngresso().getPayload()) &&
  629.                                 StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaIngresso().getPayloadParsing());
  630.                         if(!payloadParsing) {
  631.                             dumpHeaders = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaIngresso().getHeaders());
  632.                             dumpBody = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaIngresso().getPayload());
  633.                             dumpBinarioAttivatoTramiteRegolaConfigurazione = dumpHeaders || dumpBody;
  634.                         }
  635.                     }
  636.                 }
  637.                 else if(TipoMessaggio.RISPOSTA_USCITA_DUMP_BINARIO.equals(tipoMessaggio) &&
  638.                     this.dumpConfigurazione!=null && this.dumpConfigurazione.getRispostaUscita()!=null) {
  639.                     boolean payloadParsing = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaUscita().getPayload()) &&
  640.                             StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaUscita().getPayloadParsing());
  641.                     if(!payloadParsing) {
  642.                         dumpHeaders = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaUscita().getHeaders());
  643.                         dumpBody = StatoFunzionalita.ABILITATO.equals(this.dumpConfigurazione.getRispostaUscita().getPayload());
  644.                         dumpBinarioAttivatoTramiteRegolaConfigurazione = dumpHeaders || dumpBody;
  645.                     }
  646.                 }
  647.             }
  648.             
  649.             if(!dumpHeaders && !dumpBody && !dumpAttachments && !onlyLogFileTraceHeaders && !onlyLogFileTraceBody) {
  650.                 return; // disabilitato
  651.             }
  652.         }
  653.         boolean dumpMultipartHeaders = dumpHeaders;
  654.         
  655.         String identificativoDiagnostico = null;
  656.         if(dumpNormale) {
  657.             identificativoDiagnostico = emitDiagnosticDumpStart(tipoMessaggio, false);
  658.         }
  659.         else {
  660.             boolean onlyFileTrace = !dumpHeaders && !dumpBody && !dumpAttachments;
  661.             
  662.             identificativoDiagnostico = getIdentificativoDiagnostico(tipoMessaggio, onlyFileTrace);
  663.         }
  664.         
  665.         try {
  666.             dumpEngine(onlyLogFileTraceHeaders, onlyLogFileTraceBody, 
  667.                     tipoMessaggio, msg, msgBytes, messageType,
  668.                     location, transportHeaderParam,
  669.                     dumpHeaders, dumpBody, dumpAttachments, dumpMultipartHeaders, 
  670.                     dumpIntegrationManager,
  671.                     dumpBinario, dumpBinarioAttivatoTramiteRegolaConfigurazione);
  672.         }finally {
  673.             if(identificativoDiagnostico!=null && this.emitDiagnosticDump) {
  674.                 try {
  675.                     if(this.transazioneApplicativoServer!=null && this.idPortaApplicativa!=null) {
  676.                         this.msgDiagErroreDump.setTransazioneApplicativoServer(this.transazioneApplicativoServer, this.idPortaApplicativa);
  677.                     }
  678.                     this.msgDiagErroreDump.logPersonalizzato(identificativoDiagnostico+"completato");
  679.                 }catch(Exception t) {
  680.                     if(this.loggerDump!=null) {
  681.                         this.loggerDumpError("Riscontrato errore durante l'emissione del diagnostico per il dump del contenuto applicativo in corso del messaggio ("+tipoMessaggio+
  682.                                 ") "+getLogIdTransazione()+":"+t.getMessage(),t);
  683.                     }
  684.                 }finally {
  685.                     this.msgDiagErroreDump.setTransazioneApplicativoServer(null, null);
  686.                 }
  687.             }
  688.         }
  689.     }
  690.     
  691.     private String getIdentificativoDiagnostico(TipoMessaggio tipoMessaggio, boolean onlyFileTrace) {
  692.         String identificativoDiagnostico = null;
  693.         if(tipoMessaggio!=null) {
  694.             switch (tipoMessaggio) {
  695.             case RICHIESTA_INGRESSO:
  696.             case RICHIESTA_INGRESSO_DUMP_BINARIO:
  697.                 if(onlyFileTrace) {
  698.                     identificativoDiagnostico = "dumpContenutiApplicativiFileTrace.richiestaIngresso.";
  699.                 }
  700.                 else {
  701.                     identificativoDiagnostico = "dumpContenutiApplicativi.richiestaIngresso.";
  702.                 }
  703.                 break;
  704.             case RICHIESTA_USCITA:
  705.             case RICHIESTA_USCITA_DUMP_BINARIO:
  706.                 if(onlyFileTrace) {
  707.                     identificativoDiagnostico = "dumpContenutiApplicativiFileTrace.richiestaUscita.";
  708.                 }
  709.                 else {
  710.                     identificativoDiagnostico = "dumpContenutiApplicativi.richiestaUscita.";
  711.                 }
  712.                 break;
  713.             case RISPOSTA_INGRESSO:
  714.             case RISPOSTA_INGRESSO_DUMP_BINARIO:
  715.                 if(onlyFileTrace) {
  716.                     identificativoDiagnostico = "dumpContenutiApplicativiFileTrace.rispostaIngresso.";
  717.                 }
  718.                 else {
  719.                     identificativoDiagnostico = "dumpContenutiApplicativi.rispostaIngresso.";
  720.                 }
  721.                 break;
  722.             case RISPOSTA_USCITA:
  723.             case RISPOSTA_USCITA_DUMP_BINARIO:
  724.                 if(onlyFileTrace) {
  725.                     identificativoDiagnostico = "dumpContenutiApplicativiFileTrace.rispostaUscita.";
  726.                 }
  727.                 else {
  728.                     identificativoDiagnostico = "dumpContenutiApplicativi.rispostaUscita.";
  729.                 }
  730.                 break;
  731.             default:
  732.                 break;
  733.             }
  734.         }
  735.         return identificativoDiagnostico;
  736.     }
  737.     
  738.     private String emitDiagnosticDumpStart(TipoMessaggio tipoMessaggio, boolean onlyFileTrace) {
  739.         String identificativoDiagnostico = getIdentificativoDiagnostico(tipoMessaggio, onlyFileTrace);
  740.         emitDiagnosticDumpStart(tipoMessaggio, identificativoDiagnostico);
  741.         return identificativoDiagnostico;
  742.     }
  743.     private void emitDiagnosticDumpStart(TipoMessaggio tipoMessaggio, String identificativoDiagnostico) {
  744.         if(identificativoDiagnostico!=null && this.emitDiagnosticDump) {
  745.             try {
  746.                 if(this.transazioneApplicativoServer!=null && this.idPortaApplicativa!=null) {
  747.                     this.msgDiagErroreDump.setTransazioneApplicativoServer(this.transazioneApplicativoServer, this.idPortaApplicativa);
  748.                 }
  749.                 this.msgDiagErroreDump.logPersonalizzato(identificativoDiagnostico+"inCorso");
  750.             }catch(Exception t) {
  751.                 if(this.loggerDump!=null) {
  752.                     this.loggerDumpError("Riscontrato errore durante l'emissione del diagnostico per il dump del contenuto applicativo in corso del messaggio ("+tipoMessaggio+
  753.                             ") "+getLogIdTransazione()+":"+t.getMessage(),t);
  754.                 }
  755.             }finally {
  756.                 this.msgDiagErroreDump.setTransazioneApplicativoServer(null, null);
  757.             }
  758.         }
  759.     }
  760.     
  761.     
  762.     private List<String> initDumpWhiteHeaderList(TipoMessaggio tipoMessaggio) {
  763.         return initDumpHeaderList(true, tipoMessaggio);
  764.     }
  765.     private List<String> initDumpBlackHeaderList(TipoMessaggio tipoMessaggio) {
  766.         return initDumpHeaderList(false, tipoMessaggio);
  767.     }
  768.     private List<String> initDumpHeaderList(boolean whiteList, TipoMessaggio tipoMessaggio) {
  769.         
  770.         List<String> l = initDumpHeaderPorta(whiteList, tipoMessaggio);
  771.         if(l!=null && !l.isEmpty()) {
  772.             return l;
  773.         }
  774.                 
  775.         if(this.tipoPdD!=null && tipoMessaggio!=null) {
  776.             l = initDumpHeaderListRequestResponse(whiteList, tipoMessaggio);
  777.             if(l!=null && !l.isEmpty()) {
  778.                 return l;
  779.             }
  780.         }
  781.         
  782.         if(this.tipoPdD!=null) {
  783.             l = initDumpHeaderList(whiteList, 
  784.                     this.properties.getDumpHeaderErogazioniWhiteList(), 
  785.                     this.properties.getDumpHeaderErogazioniBlackList(), 
  786.                     this.properties.getDumpHeaderFruizioniWhiteList(), 
  787.                     this.properties.getDumpHeaderFruizioniBlackList());
  788.             if(l!=null && !l.isEmpty()) {
  789.                 return l;
  790.             }
  791.         }
  792.         
  793.         return whiteList ? this.properties.getDumpHeaderWhiteList() : this.properties.getDumpHeaderBlackList();
  794.     }
  795.     private List<Proprieta> getProprietaPortaList() throws DriverConfigurazioneException{
  796.         List<Proprieta> lReturn = null;
  797.         if(this.tipoPdD!=null && this.nomePorta!=null) {
  798.             
  799.             ConfigurazionePdDManager configPdDManager = ConfigurazionePdDManager.getInstance(this.statoRichiesta!=null ? this.statoRichiesta : this.statoRisposta);
  800.             
  801.             if(TipoPdD.APPLICATIVA.equals(this.tipoPdD)) {
  802.                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  803.                 idPA.setNome(this.nomePorta);
  804.                 PortaApplicativa pa = configPdDManager.getPortaApplicativaSafeMethod(idPA, this.requestInfo);
  805.                 if(pa!=null) {
  806.                     return pa.getProprieta();
  807.                 }
  808.             }
  809.             else if(TipoPdD.DELEGATA.equals(this.tipoPdD)) {
  810.                 IDPortaDelegata idPD = new IDPortaDelegata();
  811.                 idPD.setNome(this.nomePorta);
  812.                 PortaDelegata pd = configPdDManager.getPortaDelegataSafeMethod(idPD, this.requestInfo);
  813.                 if(pd!=null) {
  814.                     return pd.getProprieta();
  815.                 }
  816.             }
  817.             
  818.         }
  819.         return lReturn;
  820.     }
  821.     private List<String> initDumpHeaderPorta(boolean whiteList, TipoMessaggio tipoMessaggio) {
  822.         
  823.         List<String> l = null;
  824.         
  825.         List<Proprieta> portaProps = null;
  826.         try {
  827.             portaProps = getProprietaPortaList();
  828.         }catch(Exception e) {
  829.             this.loggerDumpError("Recupero proprietร  dalla porta '"+this.nomePorta+"' (tipo: "+this.tipoPdD+") fallito: "+e.getMessage(),e);
  830.         }
  831.         
  832.         if(portaProps!=null && !portaProps.isEmpty()) {
  833.             
  834.             l = initDumpHeaderListRequestResponsePorta(whiteList, tipoMessaggio, portaProps);
  835.             if(l!=null && !l.isEmpty()) {
  836.                 return l;
  837.             }
  838.             
  839.             List<String> white = CostantiProprieta.getRegistrazioneMessaggiWhiteList(portaProps);
  840.             List<String> black = CostantiProprieta.getRegistrazioneMessaggiBlackList(portaProps);
  841.             l = initDumpHeaderList(whiteList, 
  842.                     white, 
  843.                     black, 
  844.                     white, 
  845.                     black);
  846.             if(l!=null && !l.isEmpty()) {
  847.                 return l;
  848.             }
  849.             
  850.         }
  851.         
  852.         return l;
  853.     }
  854.     private List<String> initDumpHeaderListRequestResponsePorta(boolean whiteList, TipoMessaggio tipoMessaggio, List<Proprieta> proprieta) {
  855.         List<String> l = null;
  856.         
  857.         if(this.tipoPdD!=null && tipoMessaggio!=null) {
  858.             switch (tipoMessaggio) {
  859.             
  860.             case RICHIESTA_INGRESSO:
  861.             case RICHIESTA_INGRESSO_DUMP_BINARIO:{
  862.                 List<String> white = CostantiProprieta.getRegistrazioneMessaggiRichiestaIngressoWhiteList(proprieta);
  863.                 List<String> black = CostantiProprieta.getRegistrazioneMessaggiRichiestaIngressoBlackList(proprieta);
  864.                 l = initDumpHeaderList(whiteList, 
  865.                         white, 
  866.                         black, 
  867.                         white, 
  868.                         black);
  869.                 break;
  870.             }
  871.             case RICHIESTA_USCITA:
  872.             case RICHIESTA_USCITA_DUMP_BINARIO:{
  873.                 List<String> white = CostantiProprieta.getRegistrazioneMessaggiRichiestaUscitaWhiteList(proprieta);
  874.                 List<String> black = CostantiProprieta.getRegistrazioneMessaggiRichiestaUscitaBlackList(proprieta);
  875.                 l = initDumpHeaderList(whiteList, 
  876.                         white, 
  877.                         black, 
  878.                         white, 
  879.                         black);
  880.                 break;
  881.             }
  882.             case RISPOSTA_INGRESSO:
  883.             case RISPOSTA_INGRESSO_DUMP_BINARIO:{
  884.                 List<String> white = CostantiProprieta.getRegistrazioneMessaggiRispostaIngressoWhiteList(proprieta);
  885.                 List<String> black = CostantiProprieta.getRegistrazioneMessaggiRispostaIngressoBlackList(proprieta);
  886.                 l = initDumpHeaderList(whiteList, 
  887.                         white, 
  888.                         black, 
  889.                         white, 
  890.                         black);
  891.                 break;
  892.             }
  893.     
  894.             case RISPOSTA_USCITA:
  895.             case RISPOSTA_USCITA_DUMP_BINARIO:{
  896.                 List<String> white = CostantiProprieta.getRegistrazioneMessaggiRispostaUscitaWhiteList(proprieta);
  897.                 List<String> black = CostantiProprieta.getRegistrazioneMessaggiRispostaUscitaBlackList(proprieta);
  898.                 l = initDumpHeaderList(whiteList, 
  899.                         white, 
  900.                         black, 
  901.                         white, 
  902.                         black);
  903.                 break;
  904.             }
  905.                 
  906.             default:
  907.                 break;
  908.             }
  909.         }
  910.         return l;
  911.     }
  912.     private List<String> initDumpHeaderListRequestResponse(boolean whiteList, TipoMessaggio tipoMessaggio) {
  913.         
  914.         List<String> l = null;
  915.         
  916.         if(this.tipoPdD!=null && tipoMessaggio!=null) {
  917.             switch (tipoMessaggio) {
  918.             
  919.             case RICHIESTA_INGRESSO:
  920.             case RICHIESTA_INGRESSO_DUMP_BINARIO:
  921.                 l = initDumpHeaderList(whiteList, 
  922.                         this.properties.getDumpHeaderErogazioniRichiestaIngressoWhiteList(), 
  923.                         this.properties.getDumpHeaderErogazioniRichiestaIngressoBlackList(), 
  924.                         this.properties.getDumpHeaderFruizioniRichiestaIngressoWhiteList(), 
  925.                         this.properties.getDumpHeaderFruizioniRichiestaIngressoBlackList());
  926.                 break;
  927.     
  928.             case RICHIESTA_USCITA:
  929.             case RICHIESTA_USCITA_DUMP_BINARIO:
  930.                 l = initDumpHeaderList(whiteList, 
  931.                         this.properties.getDumpHeaderErogazioniRichiestaUscitaWhiteList(), 
  932.                         this.properties.getDumpHeaderErogazioniRichiestaUscitaBlackList(), 
  933.                         this.properties.getDumpHeaderFruizioniRichiestaUscitaWhiteList(), 
  934.                         this.properties.getDumpHeaderFruizioniRichiestaUscitaBlackList());
  935.                 break;
  936.                 
  937.             case RISPOSTA_INGRESSO:
  938.             case RISPOSTA_INGRESSO_DUMP_BINARIO:
  939.                 l = initDumpHeaderList(whiteList, 
  940.                         this.properties.getDumpHeaderErogazioniRispostaIngressoWhiteList(), 
  941.                         this.properties.getDumpHeaderErogazioniRispostaIngressoBlackList(), 
  942.                         this.properties.getDumpHeaderFruizioniRispostaIngressoWhiteList(), 
  943.                         this.properties.getDumpHeaderFruizioniRispostaIngressoBlackList());
  944.                 break;
  945.     
  946.             case RISPOSTA_USCITA:
  947.             case RISPOSTA_USCITA_DUMP_BINARIO:
  948.                 l = initDumpHeaderList(whiteList, 
  949.                         this.properties.getDumpHeaderErogazioniRispostaUscitaWhiteList(), 
  950.                         this.properties.getDumpHeaderErogazioniRispostaUscitaBlackList(), 
  951.                         this.properties.getDumpHeaderFruizioniRispostaUscitaWhiteList(), 
  952.                         this.properties.getDumpHeaderFruizioniRispostaUscitaBlackList());
  953.                 break;
  954.                 
  955.             default:
  956.                 break;
  957.             }
  958.         }
  959.         return l;
  960.     }
  961.     private List<String> initDumpHeaderList(boolean whiteList, List<String> erogazioniWhiteList, List<String> erogazioniBlackList, List<String> fruizioniWhiteList, List<String> fruizioniBlackList){
  962.         List<String> l = null;
  963.         if(TipoPdD.APPLICATIVA.equals(this.tipoPdD)) {
  964.             l = whiteList ? erogazioniWhiteList : erogazioniBlackList;
  965.         }
  966.         else if(TipoPdD.DELEGATA.equals(this.tipoPdD)) {
  967.             l = whiteList ? fruizioniWhiteList : fruizioniBlackList;
  968.         }
  969.         return l;
  970.     }
  971.     
  972.     
  973.     private void dumpEngine(boolean onlyLogFileTraceHeaders, boolean onlyLogFileTraceBody, 
  974.             TipoMessaggio tipoMessaggio,OpenSPCoop2Message msg,DumpByteArrayOutputStream msgBytes, MessageType messageType,
  975.             String location,Map<String, List<String>> transportHeaderParam,
  976.             boolean dumpHeaders, boolean dumpBody, boolean dumpAttachments, boolean dumpMultipartHeaders, 
  977.             boolean dumpIntegrationManager,
  978.             boolean dumpBinario, boolean dumpBinarioAttivatoTramiteRegolaConfigurazione) throws DumpException {
  979.         
  980.         
  981.         Messaggio messaggio = new Messaggio();
  982.         if(this.protocolFactory!=null) {
  983.             messaggio.setProtocollo(this.protocolFactory.getProtocol());
  984.         }
  985.         messaggio.setTipoMessaggio(tipoMessaggio);
  986.         if(msg!=null) {
  987.             messaggio.setFormatoMessaggio(msg.getMessageType());
  988.         }
  989.         else if(messageType!=null) {
  990.             messaggio.setFormatoMessaggio(messageType);
  991.         }
  992.         
  993.         messaggio.setGdo(DateManager.getDate());
  994.         
  995.         messaggio.setDominio(this.dominio);
  996.         messaggio.setTipoPdD(this.tipoPdD);
  997.         messaggio.setIdFunzione(this.idModulo);
  998.         
  999.         messaggio.setIdTransazione(this.idTransazione);
  1000.         messaggio.setIdBusta(this.idMessaggio);
  1001.         messaggio.setFruitore(this.fruitore);
  1002.         messaggio.setServizio(this.servizio);
  1003.         
  1004.         if(this.protocolFactory!=null) {
  1005.             messaggio.setProtocollo(this.protocolFactory.getProtocol());
  1006.         }
  1007.         
  1008.         
  1009.         
  1010.         // HEADERS
  1011.         Map<String, List<String>> transportHeader = new HashMap<>(); // uso anche sotto per content type in caso msg bytes
  1012.         try{
  1013.             if(transportHeaderParam!=null && transportHeaderParam.size()>0){
  1014.                 transportHeader.putAll(transportHeaderParam);
  1015.             }
  1016.             if(msg!=null){
  1017.                 OpenSPCoop2MessageProperties forwardHeader = null;
  1018.                 if(TipoMessaggio.RICHIESTA_USCITA.equals(tipoMessaggio)){
  1019.                     if(ServiceBinding.REST.equals(msg.getServiceBinding())) {
  1020.                         forwardHeader = msg.getForwardTransportHeader(this.properties.getRESTServicesHeadersForwardConfig(true));
  1021.                     }
  1022.                     else {
  1023.                         forwardHeader = msg.getForwardTransportHeader(this.properties.getSOAPServicesHeadersForwardConfig(true));
  1024.                     }
  1025.                 }
  1026.                 else if(TipoMessaggio.RISPOSTA_USCITA.equals(tipoMessaggio)){
  1027.                     if(ServiceBinding.REST.equals(msg.getServiceBinding())) {
  1028.                         forwardHeader = msg.getForwardTransportHeader(this.properties.getRESTServicesHeadersForwardConfig(false));
  1029.                     }
  1030.                     else {
  1031.                         forwardHeader = msg.getForwardTransportHeader(this.properties.getSOAPServicesHeadersForwardConfig(false));
  1032.                     }
  1033.                 }
  1034.                 if(forwardHeader!=null && forwardHeader.size()>0){
  1035.                     Iterator<String> enHdr = forwardHeader.getKeys();
  1036.                     while (enHdr.hasNext()) {
  1037.                         String key = enHdr.next();
  1038.                         if(key!=null){
  1039.                             List<String> values = forwardHeader.getPropertyValues(key);
  1040.                             if(values!=null && !values.isEmpty()){
  1041.                                 transportHeader.put(key, values);
  1042.                             }
  1043.                         }
  1044.                     }
  1045.                 }
  1046.             }
  1047.             if(msg!=null &&
  1048.                     !TransportUtils.containsKey(transportHeader, HttpConstants.CONTENT_TYPE)) {
  1049.                 String contentType = msg.getContentType();
  1050.                 if(contentType!=null) {
  1051.                     TransportUtils.setHeader(transportHeader, HttpConstants.CONTENT_TYPE, contentType);
  1052.                 }
  1053.             }
  1054.         }catch(Exception e){
  1055.             // Registro solo l'errore sul file dump.log
  1056.             // Si tratta di un errore che non dovrebbe mai avvenire
  1057.             String messaggioErrore = "Riscontrato errore durante la lettura degli header di trasporto del contenuto applicativo presente nel messaggio ("+tipoMessaggio+
  1058.                     ") "+getLogIdTransazione()+":"+e.getMessage();
  1059.             this.loggerDumpError(messaggioErrore);
  1060.             OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error(messaggioErrore);
  1061.         }
  1062.         if( (dumpHeaders || onlyLogFileTraceHeaders) &&
  1063.             (transportHeader!=null && transportHeader.size()>0)
  1064.             ){
  1065.                 
  1066.             List<String> filterList = null;
  1067.             boolean white = false;
  1068.             
  1069.             List<String> dumpHeaderWhiteList = initDumpWhiteHeaderList(tipoMessaggio);
  1070.             List<String> dumpHeaderBlackList = initDumpBlackHeaderList(tipoMessaggio);
  1071.             
  1072.             if(dumpHeaderWhiteList!=null && !dumpHeaderWhiteList.isEmpty()) {
  1073.                 filterList = dumpHeaderWhiteList;
  1074.                 white = true;
  1075.             }
  1076.             else if(dumpHeaderBlackList!=null && !dumpHeaderBlackList.isEmpty()) {
  1077.                 filterList = dumpHeaderBlackList;
  1078.                 white = false;
  1079.             }
  1080.             
  1081.             Iterator<String> keys = transportHeader.keySet().iterator();
  1082.             while (keys.hasNext()) {
  1083.                 String key = keys.next();                   
  1084.                 if(key!=null){
  1085.                     
  1086.                     boolean add = false;
  1087.                     if(filterList!=null) {
  1088.                         boolean find = false;
  1089.                         for (String filterHdr : filterList) {
  1090.                             if(filterHdr.equalsIgnoreCase(key)) {
  1091.                                 find = true;
  1092.                                 break;
  1093.                             }
  1094.                         }
  1095.                         if(white) {
  1096.                             if(find) {
  1097.                                 add = true;
  1098.                             }
  1099.                         }
  1100.                         else {
  1101.                             if(!find) {
  1102.                                 add = true;
  1103.                             }
  1104.                         }
  1105.                     }
  1106.                     else {
  1107.                         add = true;
  1108.                     }
  1109.                     
  1110.                     if(add) {
  1111.                         List<String> values = transportHeader.get(key);
  1112.                         messaggio.getHeaders().put(key, values);
  1113.                     }
  1114.                 }
  1115.             }
  1116.         }
  1117.         
  1118.         
  1119.         
  1120.         
  1121.         // BODY e ATTACHMENTS
  1122.         DumpMessaggio dumpMessaggio = null;
  1123.         DumpMessaggioConfig dumpMessaggioConfig = null;
  1124.         try {
  1125.             if( (dumpBody || onlyLogFileTraceBody) 
  1126.                     || 
  1127.                 dumpAttachments
  1128.                 ) {
  1129.                 if(msg!=null){
  1130.                     dumpMessaggioConfig = new DumpMessaggioConfig();
  1131.                     dumpMessaggio = fillMessaggio(msg, dumpMessaggioConfig,
  1132.                             dumpBody, dumpAttachments, dumpMultipartHeaders,
  1133.                             messaggio);
  1134.                 }
  1135.                 else {
  1136.                     
  1137.                     if( dumpBody || onlyLogFileTraceBody ) {
  1138.                     
  1139.                         if(transportHeader!=null && !transportHeader.isEmpty()) {
  1140.                             Iterator<String> keys = transportHeader.keySet().iterator();
  1141.                             while (keys.hasNext()) {
  1142.                                 String key = keys.next();
  1143.                                 if(HttpConstants.CONTENT_TYPE.equalsIgnoreCase(key)){
  1144.                                     List<String> values = transportHeader.get(key); 
  1145.                                     if(values!=null && !values.isEmpty()) {
  1146.                                         messaggio.setContentType(values.get(0));
  1147.                                     }
  1148.                                     break;
  1149.                                 }
  1150.                             }
  1151.                         }
  1152.                         
  1153.                         messaggio.setBody(msgBytes);
  1154.                     }
  1155.                 }
  1156.             }
  1157.         }catch(Exception e){
  1158.             try{
  1159.                 // Registro l'errore sul file dump.log
  1160.                 this.loggerDumpError("Riscontrato errore durante la preparazione al dump del contenuto applicativo presente nel messaggio ("+tipoMessaggio+
  1161.                         ") "+getLogIdTransazione()+":"+e.getMessage());
  1162.             }catch(Exception eLog){
  1163.                 // ignore
  1164.             }
  1165.             loggerOpenSPCoopResourcesError("Errore durante la preparazione al dump del contenuto applicativo presente nel messaggio ("+tipoMessaggio+
  1166.                     ") "+getLogIdTransazione()+": "+e.getMessage(),e);
  1167.             try{
  1168.                 this.msgDiagErroreDump.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, tipoMessaggio.getValue());
  1169.                 this.msgDiagErroreDump.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  1170.                 this.msgDiagErroreDump.logPersonalizzato(DIAGNOSTICO_REGISTRAZIONE_NON_RIUSCITA);
  1171.             }catch(Exception eMsg){
  1172.                 // ignore
  1173.             }
  1174.             gestioneErroreDump(e);
  1175.         }
  1176.         
  1177.         
  1178.         
  1179.         
  1180.         
  1181.         // TransazioneContext
  1182.         if(this.properties.isTransazioniSaveDumpInUniqueTransaction() || onlyLogFileTraceBody || onlyLogFileTraceHeaders) {
  1183.             
  1184.             
  1185.             if(this.transazioneApplicativoServer!=null) {
  1186.                 try {
  1187.                     // forzo
  1188.                     messaggio.setIdTransazione(this.transazioneApplicativoServer.getIdTransazione());
  1189.                     messaggio.setServizioApplicativoErogatore(this.transazioneApplicativoServer.getServizioApplicativoErogatore());
  1190.                     messaggio.setDataConsegna(this.dataConsegnaTransazioneApplicativoServer);
  1191.                     GestoreConsegnaMultipla.getInstance().safeSave(messaggio, this.idPortaApplicativa, this.statoRichiesta!=null ? this.statoRichiesta : this.statoRisposta, this.requestInfo, this.pddContext);
  1192.                 }catch(Exception t) {
  1193.                     String msgError = "Errore durante il salvataggio delle informazioni relative al servizio applicativo: "+t.getMessage();
  1194.                     this.loggerDumpError(msgError,t);
  1195.                     loggerOpenSPCoopResourcesError(msgError,t);
  1196.                     try{
  1197.                         this.msgDiagErroreDump.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, tipoMessaggio.getValue());
  1198.                         this.msgDiagErroreDump.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,t.getMessage());
  1199.                         this.msgDiagErroreDump.logPersonalizzato(DIAGNOSTICO_REGISTRAZIONE_NON_RIUSCITA);
  1200.                     }catch(Exception eMsg){
  1201.                         // ignore
  1202.                     }
  1203.                     gestioneErroreDump(t);
  1204.                 }
  1205.             }
  1206.             else {
  1207.             
  1208.                 Exception exc = null;
  1209.                 boolean gestioneStateful = false;
  1210.                 try {
  1211.                     Transaction tr = TransactionContext.getTransaction(this.idTransazione);
  1212.                     if(messaggio.getBody()!=null) {
  1213.                         messaggio.getBody().lock();
  1214.                     }
  1215.                     tr.addMessaggio(messaggio, onlyLogFileTraceHeaders, onlyLogFileTraceBody);
  1216.                 }catch(TransactionDeletedException | TransactionNotExistsException e){
  1217.                     gestioneStateful = true;
  1218.                 }catch(Exception e){
  1219.                     exc = e;
  1220.                 }
  1221.                 if(gestioneStateful && !dumpIntegrationManager){
  1222.                     try{
  1223.                         /**System.out.println("@@@@@REPOSITORY@@@@@ LOG DUMP ID TRANSAZIONE ["+idTransazione+"] ADD");*/
  1224.                         RepositoryGestioneStateful.addMessaggio(this.idTransazione, messaggio);
  1225.                     }catch(Exception e){
  1226.                         exc = e;
  1227.                     }
  1228.                 }
  1229.                 if(exc!=null) {
  1230.                     try{
  1231.                         // Registro l'errore sul file dump.log
  1232.                         this.loggerDumpError("Riscontrato errore durante la registrazione, nel contesto della transazione, del dump del contenuto applicativo presente nel messaggio ("+tipoMessaggio+
  1233.                                 ") "+getLogIdTransazione()+":"+exc.getMessage());
  1234.                     }catch(Exception eLog){
  1235.                         // ignore
  1236.                     }
  1237.                     loggerOpenSPCoopResourcesError("Errore durante la registrazione, nel contesto della transazione, del contenuto applicativo presente nel messaggio ("+tipoMessaggio+
  1238.                             ") "+getLogIdTransazione()+": "+exc.getMessage(),exc);
  1239.                     try{
  1240.                         this.msgDiagErroreDump.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, tipoMessaggio.getValue());
  1241.                         this.msgDiagErroreDump.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,exc.getMessage());
  1242.                         this.msgDiagErroreDump.logPersonalizzato(DIAGNOSTICO_REGISTRAZIONE_NON_RIUSCITA);
  1243.                     }catch(Exception eMsg){
  1244.                         // ignore
  1245.                     }
  1246.                     gestioneErroreDump(exc);
  1247.                 }
  1248.                 
  1249.             }
  1250.         }
  1251.         
  1252.         // Log4J
  1253.         if(OpenSPCoop2Logger.loggerDumpAbilitato && 
  1254.                 (!dumpBinario || dumpBinarioAttivatoTramiteRegolaConfigurazione) // Se attivato da console deve finire in dump.log
  1255.                 ){
  1256.             // Su file di log, il log binario viene registrato in altra maniera sul file openspcoop2_connettori.log
  1257.             try{
  1258.                 StringBuilder out = new StringBuilder();
  1259.                 out.append(this.signature);
  1260.                 out.append("TipoMessaggio:"+tipoMessaggio.getValue());
  1261.                 
  1262.                 if(this.idTransazione!=null){
  1263.                     out.append(" idTransazione:");
  1264.                     out.append(this.idTransazione);
  1265.                 }
  1266.                 
  1267.                 if(this.idMessaggio!=null){
  1268.                     out.append(" idMessaggio:");
  1269.                     out.append(this.idMessaggio);
  1270.                 }
  1271.                 
  1272.                 if(location!=null){
  1273.                     if(TipoMessaggio.RICHIESTA_INGRESSO.equals(tipoMessaggio) || TipoMessaggio.RISPOSTA_USCITA.equals(tipoMessaggio)){
  1274.                         out.append(" source:");
  1275.                     }else{
  1276.                         out.append(" location:");
  1277.                     }
  1278.                     out.append(location);
  1279.                 }
  1280.                 
  1281.                 if( this.fruitore!=null ){
  1282.                     out.append(" FR:");
  1283.                     out.append(this.fruitore.toString());
  1284.                 }
  1285.                 if( this.fruitore!=null && this.servizio!=null)
  1286.                     out.append(" -> ");
  1287.                 if( this.servizio!=null ){
  1288.                     if(this.servizio.getNome()!=null){
  1289.                         out.append(" S:");
  1290.                         try{
  1291.                             out.append(IDServizioFactory.getInstance().getUriFromIDServizio(this.servizio));
  1292.                         }catch(Exception e){
  1293.                             out.append(this.servizio.toString(false));
  1294.                         }
  1295.                     }else if(this.servizio.getSoggettoErogatore()!=null){
  1296.                         out.append(" ER:");
  1297.                         out.append(this.servizio.getSoggettoErogatore().toString());
  1298.                     }
  1299.                 }
  1300.                 
  1301.                 out.append(" \n");
  1302.                 
  1303.                 // HEADER
  1304.                 
  1305.                 if(dumpHeaders) {
  1306.                     out.append("------ Header di trasporto ------\n");
  1307.                     if(messaggio.getHeaders()!=null && messaggio.getHeaders().size()>0) {
  1308.                         Iterator<?> it = messaggio.getHeaders().keySet().iterator();
  1309.                         while (it.hasNext()) {
  1310.                             String key = (String) it.next();
  1311.                             if(key!=null){
  1312.                                 List<String> values = messaggio.getHeaders().get(key);
  1313.                                 if(values!=null && !values.isEmpty()) {
  1314.                                     for (String value : values) {
  1315.                                         out.append("- "+key+": "+value+"\n");
  1316.                                     }
  1317.                                 }
  1318.                             }
  1319.                         }
  1320.                     }
  1321.                     else {
  1322.                         out.append("Non presenti\n");
  1323.                     }
  1324.                 }
  1325.                 
  1326.                 // BODY e ATTACHMENTS
  1327.                 
  1328.                 if(dumpBody || dumpAttachments) {
  1329.                     if(msg!=null){
  1330.     
  1331.                         if(dumpAttachments && !this.properties.isDumpAllAttachments()) {
  1332.                             // Ricalcolo gli attachments prendendo solo quelli stampabili
  1333.                             if(ServiceBinding.SOAP.equals(msg.getServiceBinding())){
  1334.                                 dumpMessaggio = DumpSoapMessageUtils.dumpMessage(msg.castAsSoap(), dumpMessaggioConfig, false);
  1335.                             }
  1336.                             else{
  1337.                                 dumpMessaggio = DumpRestMessageUtils.dumpMessage(msg.castAsRest(), dumpMessaggioConfig, false);
  1338.                             }
  1339.                         }
  1340.                         
  1341.                         if(dumpMessaggio!=null) {
  1342.                             out.append(dumpMessaggio.toString(dumpMessaggioConfig,this.properties.isDumpAllAttachments()));
  1343.                         }
  1344.     
  1345.                     }else{
  1346.                         if(msgBytes!=null && msgBytes.size()>0) {
  1347.                             if(org.openspcoop2.utils.mime.MultipartUtils.messageWithAttachment(msgBytes.toByteArray())){
  1348.                                 out.append("------ MessageWithAttachments ------\n");
  1349.                             }else{
  1350.                                 out.append("------ Message ------\n");
  1351.                             }
  1352.                             out.append(msgBytes.toString());
  1353.                         }
  1354.                         else {
  1355.                             out.append("------ Message ------\n");
  1356.                             out.append("Non presente\n");
  1357.                         }
  1358.                     }
  1359.                 
  1360.                 }
  1361.                 
  1362.                 String msgDump = out.toString();
  1363.                 this.loggerDump.info(msgDump); 
  1364.                 
  1365.             }catch(Exception e){
  1366.                 try{
  1367.                     // Registro l'errore sul file dump.log
  1368.                     this.loggerDumpError("Riscontrato errore durante il dump su file di log del contenuto applicativo presente nel messaggio ("+tipoMessaggio+
  1369.                             ") "+getLogIdTransazione()+":"+e.getMessage());
  1370.                 }catch(Exception eLog){
  1371.                     // ignore
  1372.                 }
  1373.                 loggerOpenSPCoopResourcesError("Errore durante il dump su file di log del contenuto applicativo presente nel messaggio ("+tipoMessaggio+
  1374.                         ") "+getLogIdTransazione()+": "+e.getMessage(),e);
  1375.                 try{
  1376.                     this.msgDiagErroreDump.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, tipoMessaggio.getValue());
  1377.                     this.msgDiagErroreDump.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  1378.                     this.msgDiagErroreDump.logPersonalizzato(DIAGNOSTICO_REGISTRAZIONE_NON_RIUSCITA);
  1379.                 }catch(Exception eMsg){
  1380.                     // ignore
  1381.                 }
  1382.                 gestioneErroreDump(e);
  1383.             }
  1384.         }
  1385.         
  1386.         // Il dump via API lo effettuo solamente se ho davvero un messaggio OpenSPCoop
  1387.         // Senno ottengo errori all'interno delle implementazioni degli appender dump
  1388.         boolean onlyLogFileTrace = false;
  1389.         if( (onlyLogFileTraceHeaders && !dumpHeaders)
  1390.                 ||
  1391.             (onlyLogFileTraceBody && !dumpBody) ) {
  1392.             onlyLogFileTrace=true;
  1393.         }
  1394.         if(!onlyLogFileTrace && !dumpIntegrationManager) {
  1395.             for(int i=0; i<this.loggerDumpOpenSPCoopAppender.size();i++){
  1396.                 try{
  1397.                     boolean headersCompact = false; //non supportato nei plugins
  1398.                     this.loggerDumpOpenSPCoopAppender.get(i).dump(getConnectionFromState(false),messaggio,headersCompact);
  1399.                 }catch(Exception e){
  1400.                     loggerOpenSPCoopResourcesError("Errore durante il dump personalizzato ["+this.tipoDumpOpenSPCoopAppender.get(i)+
  1401.                             "] del contenuto applicativo presente nel messaggio ("+tipoMessaggio+") "+getLogIdTransazione()+": "+e.getMessage(),e);
  1402.                     try{
  1403.                         this.msgDiagErroreDump.addKeyword(CostantiPdD.KEY_TRACCIA_TIPO, tipoMessaggio.getValue());
  1404.                         this.msgDiagErroreDump.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_ERRORE,e.getMessage());
  1405.                         this.msgDiagErroreDump.addKeyword(CostantiPdD.KEY_TRACCIAMENTO_PERSONALIZZATO,this.tipoDumpOpenSPCoopAppender.get(i));
  1406.                         this.msgDiagErroreDump.logPersonalizzato("dumpContenutiApplicativi.registrazioneNonRiuscita.openspcoopAppender");
  1407.                     }catch(Exception eMsg){
  1408.                         // ignore
  1409.                     }
  1410.                     gestioneErroreDump(e);
  1411.                 }
  1412.             }
  1413.         }

  1415.     }
  1416.     
  1417.     public static DumpMessaggio fillMessaggio(OpenSPCoop2Message msg, DumpMessaggioConfig dumpMessaggioConfig,
  1418.             boolean dumpBody, boolean dumpAttachments, boolean dumpMultipartHeaders,
  1419.             Messaggio messaggio) throws MessageException  {
  1420.             
  1421.         DumpMessaggio dumpMessaggio = null;
  1422.         
  1423.         dumpMessaggioConfig.setDumpBody(dumpBody);
  1424.         dumpMessaggioConfig.setDumpHeaders(false); // utilizzo sempre quello fornito poiche' per il raw il msg openspcoop2 non e' disponibile, altrimenti perche' devo considerare i forward header
  1425.         dumpMessaggioConfig.setDumpAttachments(dumpAttachments);
  1426.         dumpMessaggioConfig.setDumpMultipartHeaders(dumpMultipartHeaders);
  1427.         
  1428.         if(ServiceBinding.SOAP.equals(msg.getServiceBinding())){
  1429.             dumpMessaggio = DumpSoapMessageUtils.dumpMessage(msg.castAsSoap(), dumpMessaggioConfig, true); /**!Devo leggere tutti gli attachments! this.properties.isDumpAllAttachments());*/
  1430.         }
  1431.         else{
  1432.             dumpMessaggio = DumpRestMessageUtils.dumpMessage(msg.castAsRest(), dumpMessaggioConfig, true); /**!Devo leggere tutti gli attachments! this.properties.isDumpAllAttachments());*/
  1433.         }
  1434.         
  1435.         messaggio.setContentType(dumpMessaggio.getContentType());
  1436.         
  1437.         if(dumpBody) {
  1438.             messaggio.setBody(DumpByteArrayOutputStream.newInstance(dumpMessaggio.getBody()));
  1439.             if(dumpMessaggio.getMultipartInfoBody()!=null) {
  1440.                 BodyMultipartInfo bodyMultipartInfo = new BodyMultipartInfo();
  1441.                 
  1442.                 bodyMultipartInfo.setContentId(dumpMessaggio.getMultipartInfoBody().getContentId());
  1443.                 bodyMultipartInfo.setContentLocation(dumpMessaggio.getMultipartInfoBody().getContentLocation());
  1444.                 bodyMultipartInfo.setContentType(dumpMessaggio.getMultipartInfoBody().getContentType());
  1445.                 
  1446.                 if(dumpMultipartHeaders &&
  1447.                     dumpMessaggio.getMultipartInfoBody().getHeadersValues()!=null &&
  1448.                     dumpMessaggio.getMultipartInfoBody().getHeadersValues().size()>0) {
  1449.                     Iterator<?> it = dumpMessaggio.getMultipartInfoBody().getHeadersValues().keySet().iterator();
  1450.                     while (it.hasNext()) {
  1451.                         String key = (String) it.next();
  1452.                         List<String> values = dumpMessaggio.getMultipartInfoBody().getHeadersValues().get(key);
  1453.                         bodyMultipartInfo.getHeaders().put(key, values);
  1454.                     }
  1455.                 }
  1456.                 
  1457.                 messaggio.setBodyMultipartInfo(bodyMultipartInfo);
  1458.             }
  1459.         }
  1460.         
  1461.         if(dumpAttachments && dumpMessaggio.getAttachments()!=null &&
  1462.                 !dumpMessaggio.getAttachments().isEmpty()) {
  1463.             for (DumpAttachment dumpAttach : dumpMessaggio.getAttachments()) {
  1464.                 
  1465.                 Attachment attachment = new Attachment();
  1466.                 
  1467.                 attachment.setContentId(dumpAttach.getContentId());
  1468.                 attachment.setContentLocation(dumpAttach.getContentLocation());
  1469.                 attachment.setContentType(dumpAttach.getContentType());
  1470.                 
  1471.                 if(dumpMultipartHeaders &&
  1472.                     dumpAttach.getHeadersValues()!=null &&
  1473.                     dumpAttach.getHeadersValues().size()>0) {
  1474.                     Iterator<?> it = dumpAttach.getHeadersValues().keySet().iterator();
  1475.                     while (it.hasNext()) {
  1476.                         String key = (String) it.next();
  1477.                         List<String> values = dumpAttach.getHeadersValues().get(key);
  1478.                         attachment.getHeaders().put(key, values);
  1479.                     }
  1480.                 }
  1481.                 
  1482.                 if(dumpAttach.getContent()!=null)
  1483.                     attachment.setContent(dumpAttach.getContent());
  1484.                 else if(dumpAttach.getErrorContentNotSerializable()!=null)
  1485.                     attachment.setContent(dumpAttach.getErrorContentNotSerializable().getBytes());
  1486.                 else
  1487.                     throw new MessageException("Contenuto dell'attachment con id '"+attachment.getContentId()+"' non presente ?");
  1488.                 
  1489.                 messaggio.getAttachments().add(attachment);
  1490.             }
  1491.         }
  1492.         
  1493.         return dumpMessaggio;
  1494.     }

  1496.     
  1497.     private void gestioneErroreDump(Throwable e) throws DumpException{
  1498.         
  1499.         if(this.properties.isDumpFallitoBloccoServiziPdD()){
  1500.             Dump.setSistemaDumpDisponibile(false);
  1501.             Dump.setMotivoMalfunzionamentoDump(e);
  1502.             try{
  1503.                 this.msgDiagErroreDump.logPersonalizzato("dumpContenutiApplicativi.errore.bloccoServizi");
  1504.             }catch(Exception eMsg){
  1505.                 // ignore
  1506.             }
  1507.             loggerOpenSPCoopResourcesError("Il Sistema di dump dei contenuti applicativi ha rilevato un errore "+
  1508.                     "durante la registrazione di un contenuto applicativo, tutti i servizi/moduli della porta di dominio sono sospesi."+
  1509.                     " Si richiede un intervento sistemistico per la risoluzione del problema e il riavvio di GovWay. "+
  1510.                     "Errore rilevato: ",e);
  1511.         }
  1512.         
  1513.         if(this.properties.isDumpFallitoBloccaCooperazioneInCorso()){
  1514.             throw new DumpException(e);
  1515.         }
  1516.     }
  1517.     
  1518.     private String getLogIdTransazione() {
  1519.         return "con identificativo di transazione ["+this.idTransazione+"]";
  1520.     }
  1521. }
Created with JaCoCo 0.8.8.202204050719