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



  23. package org.openspcoop2.protocol.basic.dump;

  25. import java.io.File;
  26. import java.io.FileInputStream;
  27. import java.sql.Connection;
  28. import java.sql.PreparedStatement;
  29. import java.text.SimpleDateFormat;
  30. import java.util.ArrayList;
  31. import java.util.Date;
  32. import java.util.HashMap;
  33. import java.util.Iterator;
  34. import java.util.List;
  35. import java.util.Map;

  37. import org.openspcoop2.core.config.OpenspcoopAppender;
  38. import org.openspcoop2.core.constants.CostantiDB;
  39. import org.openspcoop2.core.transazioni.DumpAllegato;
  40. import org.openspcoop2.core.transazioni.DumpContenuto;
  41. import org.openspcoop2.core.transazioni.DumpHeaderAllegato;
  42. import org.openspcoop2.core.transazioni.DumpHeaderTrasporto;
  43. import org.openspcoop2.core.transazioni.DumpMessaggio;
  44. import org.openspcoop2.core.transazioni.DumpMultipartHeader;
  45. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  46. import org.openspcoop2.core.transazioni.dao.jdbc.JDBCServiceManager;
  47. import org.openspcoop2.core.transazioni.utils.PropertiesSerializator;
  48. import org.openspcoop2.core.transazioni.utils.TransactionContentUtils;
  49. import org.openspcoop2.generic_project.utils.ServiceManagerProperties;
  50. import org.openspcoop2.message.constants.MessageType;
  51. import org.openspcoop2.protocol.basic.BasicConnectionResult;
  52. import org.openspcoop2.protocol.basic.BasicProducer;
  53. import org.openspcoop2.protocol.basic.BasicProducerType;
  54. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  55. import org.openspcoop2.protocol.sdk.ProtocolException;
  56. import org.openspcoop2.protocol.sdk.dump.Attachment;
  57. import org.openspcoop2.protocol.sdk.dump.DumpException;
  58. import org.openspcoop2.protocol.sdk.dump.IDumpProducer;
  59. import org.openspcoop2.protocol.sdk.dump.Messaggio;
  60. import org.openspcoop2.protocol.sdk.tracciamento.TracciamentoException;
  61. import org.openspcoop2.utils.Utilities;
  62. import org.openspcoop2.utils.date.DateUtils;
  63. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  64. import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
  65. import org.openspcoop2.utils.sql.ISQLQueryObject;
  66. import org.openspcoop2.utils.sql.SQLObjectFactory;
  67. import org.openspcoop2.utils.transport.TransportUtils;




  72. /**
  73.  * Contiene l'implementazione di un appender personalizzato,
  74.  * per la registrazione del dump su database.
  75.  *
  76.  * @author Poli Andrea (apoli@link.it)
  77.  * @author $Author$
  78.  * @version $Rev$, $Date$
  79.  */

  81. public class DumpProducer extends BasicProducer implements IDumpProducer{

  83.     public DumpProducer(IProtocolFactory<?> factory) throws ProtocolException{
  84.         super(factory, BasicProducerType.DUMP);
  85.     }

  87.     /**
  88.      * Inizializza l'engine di un appender per la registrazione
  89.      * di un tracciamento emesso da una porta di dominio.
  90.      * 
  91.      * @param appenderProperties Proprieta' dell'appender
  92.      * @throws TracciamentoException
  93.      */
  94.     @Override
  95.     public void initializeAppender(OpenspcoopAppender appenderProperties) throws DumpException{
  96.         try{
  97.             this.initializeAppender(appenderProperties, true);
  98.         }catch(Exception e){
  99.             throw new DumpException("Errore durante l'inizializzazione dell'appender: "+e.getMessage(),e);
  100.         }
  101.     }



  105.     /**
  106.      * Dump di un messaggio
  107.      * 
  108.      * @param conOpenSPCoopPdD Connessione verso il database
  109.      * @param messaggio
  110.      * @throws DumpException
  111.      */
  112.     @SuppressWarnings("deprecation")
  113.     @Deprecated
  114.     @Override
  115.     public void dump(Connection conOpenSPCoopPdD,Messaggio messaggio) throws DumpException{
  116.         this.dump(conOpenSPCoopPdD, messaggio, false);
  117.     }
  118.     @Override
  119.     public void dump(Connection conOpenSPCoopPdD,Messaggio messaggio,boolean headersCompact) throws DumpException{

  121.         if(messaggio==null)
  122.             throw new DumpException("Errore durante il dump: messaggio is null");

  124.         if(messaggio.getIdTransazione()==null)
  125.             throw new DumpException("Errore durante il dump: id transazione is null");

  127.         Date gdo = messaggio.getGdo();
  128.         
  129.         String protocollo = messaggio.getProtocollo();
  130.         
  131.         String idTransazione = messaggio.getIdTransazione();
  132.         
  133.         TipoMessaggio tipoMessaggio = messaggio.getTipoMessaggio();
  134.         
  135.         MessageType formatoMessaggio = messaggio.getFormatoMessaggio();
  136.         
  137.         String servizioApplicativoErogatore = messaggio.getServizioApplicativoErogatore();
  138.         Date dataConsegnaErogatore = messaggio.getDataConsegna();
  139.         
  140.         String identificativoDump = "["+idTransazione+"]["+tipoMessaggio+"]";
  141.         if(servizioApplicativoErogatore!=null) {
  142.             identificativoDump=identificativoDump+"["+servizioApplicativoErogatore+"]";
  143.         }
  144.         if(dataConsegnaErogatore!=null) {
  145.             identificativoDump=identificativoDump+"["+DateUtils.getSimpleDateFormatMs().format(dataConsegnaErogatore)+"]";
  146.         }
  147.         
  148.         if(this.debug){
  149.             this.log.debug("@@ log"+identificativoDump+" ....");
  150.         }
  151.         
  152.         Connection con = null;
  153.         BasicConnectionResult cr = null;
  154.         try{
  155.             //  Connessione al DB
  156.             cr = this.getConnection(conOpenSPCoopPdD,"dump.log");
  157.             con = cr.getConnection();

  159.             if(this.debug){
  160.                 this.log.debug("@@ log"+identificativoDump+" (getConnection finished) ....");
  161.             }
  162.             
  163.             ServiceManagerProperties smProperties = new ServiceManagerProperties();
  164.             smProperties.setDatabaseType(this.tipoDatabase);
  165.             smProperties.setShowSql(this.debug);
  166.             smProperties.setAutomaticTransactionManagement(con.getAutoCommit());
  167.             JDBCServiceManager jdbcServiceManager = new JDBCServiceManager(con, smProperties);
  168.             
  169.             org.openspcoop2.core.transazioni.dao.IDumpMessaggioService dumpMessageService = jdbcServiceManager.getDumpMessaggioService();
  170.             
  171.             SimpleDateFormat dateformat = null;
  172.             if(this.debug) {
  173.                 dateformat = DateUtils.getSimpleDateFormatMs();
  174.             }
  175.                         
  176.             // MESSAGGIO BASE
  177.             
  178.             File fDump = null;
  179.             
  180.             DumpMessaggio dumpMessaggio = new DumpMessaggio();
  181.             dumpMessaggio.setProtocollo(protocollo);
  182.             dumpMessaggio.setIdTransazione(idTransazione);
  183.             dumpMessaggio.setServizioApplicativoErogatore(servizioApplicativoErogatore);
  184.             dumpMessaggio.setDataConsegnaErogatore(dataConsegnaErogatore);
  185.             dumpMessaggio.setTipoMessaggio(tipoMessaggio);
  186.                         
  187.             if(this.debug){
  188.                 this.log.debug("formato-messaggio: "+formatoMessaggio);
  189.                 this.log.debug("gdo: "+dateformat.format(gdo));
  190.                 this.log.debug("content-type["+messaggio.getContentType()+"]");
  191.                 if(messaggio.getBody()==null) {
  192.                     this.log.debug("body undefined");
  193.                 }
  194.                 else {
  195.                     this.log.debug("body: "+Utilities.convertBytesToFormatString(messaggio.getBody().size()));
  196.                 }
  197.             }
  198.             if(formatoMessaggio!=null) {
  199.                 dumpMessaggio.setFormatoMessaggio(formatoMessaggio.name());
  200.             }
  201.             dumpMessaggio.setDumpTimestamp(gdo);
  202.             dumpMessaggio.setContentType(messaggio.getContentType());
  203.             if(messaggio.getBody()!=null && messaggio.getBody().size()>0) {
  204.                 if(!messaggio.getBody().isSerializedOnFileSystem()) {           
  205.                     dumpMessaggio.setBody(messaggio.getBody().toByteArray());
  206.                     dumpMessaggio.setContentLength(Long.valueOf(messaggio.getBody().size()));
  207.                 }
  208.                 else {
  209.                     fDump = messaggio.getBody().getSerializedFile();
  210.                     dumpMessaggio.setContentLength(fDump.length());
  211.                 }
  212.             }
  213.             
  214.             if(messaggio.getBodyMultipartInfo()!=null) {
  215.                 if(this.debug){
  216.                     this.log.debug("multipart-body-content-id["+messaggio.getBodyMultipartInfo().getContentId()+"]");
  217.                     this.log.debug("multipart-body-content-location["+messaggio.getBodyMultipartInfo().getContentLocation()+"]");
  218.                     this.log.debug("multipart-body-content-type["+messaggio.getBodyMultipartInfo().getContentType()+"]");
  219.                 }
  220.                 dumpMessaggio.setMultipartContentId(messaggio.getBodyMultipartInfo().getContentId());
  221.                 dumpMessaggio.setMultipartContentLocation(messaggio.getBodyMultipartInfo().getContentLocation());
  222.                 dumpMessaggio.setMultipartContentType(messaggio.getBodyMultipartInfo().getContentType());
  223.                 if(messaggio.getBodyMultipartInfo().getHeaders()!=null && 
  224.                         messaggio.getBodyMultipartInfo().getHeaders().size()>0) {
  225.                     if(this.debug){
  226.                         this.log.debug("Dump "+messaggio.getBodyMultipartInfo().getHeaders().size()+" multipart-body headers");
  227.                     }
  228.                     
  229.                     Map<String, List<String>> propertiesHdr = new HashMap<>();
  230.                     List<DumpMultipartHeader> backupFailed = new ArrayList<DumpMultipartHeader>();
  231.                     
  232.                     Iterator<String> keys = messaggio.getBodyMultipartInfo().getHeaders().keySet().iterator();
  233.                     while (keys.hasNext()) {
  234.                         String key = (String) keys.next();
  235.                         
  236.                         List<String> values = messaggio.getBodyMultipartInfo().getHeaders().get(key);
  237.                         if(values!=null && !values.isEmpty()) {
  238.                             for (String value : values) {
  239.                                 if(value==null){
  240.                                     value = ""; // puo' succedere in alcuni casi.
  241.                                 }
  242.                                 if(this.debug){
  243.                                     this.log.debug("\t\t"+key+"="+value);
  244.                                 }
  245.                                 
  246.                                 DumpMultipartHeader headerMultipart = new DumpMultipartHeader();
  247.                                 headerMultipart.setNome(key);
  248.                                 headerMultipart.setValore(value.toString());
  249.                                 headerMultipart.setDumpTimestamp(gdo);
  250.                                 
  251.                                 if(headersCompact) {
  252.                                     TransportUtils.addHeader(propertiesHdr, key, value);
  253.                                     backupFailed.add(headerMultipart);
  254.                                 }
  255.                                 else {
  256.                                     dumpMessaggio.addMultipartHeader(headerMultipart);
  257.                                 }       
  258.                             }
  259.                         }
  260.                         
  261.                     }
  262.                     
  263.                     if(headersCompact) {
  264.                         PropertiesSerializator ps = new PropertiesSerializator(propertiesHdr);
  265.                         try{
  266.                             dumpMessaggio.setMultipartHeaderExt(ps.convertToDBColumnValue());
  267.                             backupFailed.clear();
  268.                             backupFailed = null;
  269.                         }catch(Throwable e){
  270.                             // NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  271.                             this.log.error("Errore durante la conversione degli header multipart: "+e.getMessage(),e);
  272.                             for (DumpMultipartHeader dumpMultipartHeader : backupFailed) {
  273.                                 dumpMessaggio.addMultipartHeader(dumpMultipartHeader);
  274.                             }
  275.                         }
  276.                     }
  277.                 }
  278.             }
  279.             
  280.             dumpMessaggio.setPostProcessed(1);
  281.             
  282.             
  283.             
  284.             // HEADER TRASPORTO
  285.             if(messaggio.getHeaders()!=null && messaggio.getHeaders().size()>0){
  286.                 if(this.debug){
  287.                     this.log.debug("Dump "+messaggio.getHeaders().size()+" headers");
  288.                 }

  290.                 Map<String, List<String>> propertiesHdr = new HashMap<>();
  291.                 List<DumpHeaderTrasporto> backupFailed = new ArrayList<DumpHeaderTrasporto>();
  292.                 
  293.                 Iterator<String> keys = messaggio.getHeaders().keySet().iterator();
  294.                 while (keys.hasNext()) {
  295.                     String key = (String) keys.next();
  296.                     
  297.                     List<String> values = messaggio.getHeaders().get(key);
  298.                     if(values!=null && !values.isEmpty()) {
  299.                         for (String value : values) {               
  300.                             if(value==null){
  301.                                 value = ""; // puo' succedere in alcuni casi.
  302.                             }
  303.                             if(this.debug){
  304.                                 this.log.debug("\t\t"+key+"="+value);
  305.                             }
  306.         
  307.                             DumpHeaderTrasporto headerTrasporto = new DumpHeaderTrasporto();
  308.                             headerTrasporto.setNome(key);
  309.                             headerTrasporto.setValore(value.toString());
  310.                             headerTrasporto.setDumpTimestamp(gdo);
  311.                             
  312.                             if(headersCompact) {
  313.                                 TransportUtils.addHeader(propertiesHdr,key, value);
  314.                                 backupFailed.add(headerTrasporto);
  315.                             }
  316.                             else {
  317.                                 dumpMessaggio.addHeaderTrasporto(headerTrasporto);
  318.                             }
  319.                         }
  320.                     }
  321.                 }
  322.                 
  323.                 if(headersCompact) {
  324.                     PropertiesSerializator ps = new PropertiesSerializator(propertiesHdr);
  325.                     try{
  326.                         dumpMessaggio.setHeaderExt(ps.convertToDBColumnValue());
  327.                         backupFailed.clear();
  328.                         backupFailed = null;
  329.                     }catch(Throwable e){
  330.                         // NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  331.                         this.log.error("Errore durante la conversione degli header: "+e.getMessage(),e);
  332.                         for (DumpHeaderTrasporto dumpHeader : backupFailed) {
  333.                             dumpMessaggio.addHeaderTrasporto(dumpHeader);
  334.                         }
  335.                     }
  336.                 }
  337.             }
  338.             
  339.             // ALLEGATI
  340.             if(messaggio.getAttachments()!=null && messaggio.getAttachments().size()>0) {
  341.                 
  342.                 if(this.debug){
  343.                     this.log.debug("Dump "+messaggio.getAttachments().size()+" attachments");
  344.                 }
  345.                 
  346.                 for (Attachment attach : messaggio.getAttachments()) {
  347.                     if(this.debug){
  348.                         this.log.debug("Attachment:");
  349.                         this.log.debug("\t\tId["+attach.getContentId()+"]");
  350.                         this.log.debug("\t\tlocation["+attach.getContentLocation()+"]");
  351.                         this.log.debug("\t\ttype["+attach.getContentType()+"]");
  352.                         if(attach.getContent()==null) {
  353.                             this.log.debug("\t\tcontent undefined");
  354.                         }
  355.                         else {
  356.                             this.log.debug("\t\tcontent: "+Utilities.convertBytesToFormatString(attach.getContent().length));
  357.                         }
  358.                     }

  360.                     DumpAllegato dumpAllegato = new DumpAllegato();
  361.                     dumpAllegato.setContentId(attach.getContentId());
  362.                     dumpAllegato.setContentLocation(attach.getContentLocation());
  363.                     dumpAllegato.setContentType(attach.getContentType());
  364.                     dumpAllegato.setAllegato(attach.getContent());
  365.                     dumpAllegato.setDumpTimestamp(gdo);
  366.                     dumpMessaggio.addAllegato(dumpAllegato);
  367.                     
  368.                     
  369.                     if(attach.getHeaders()!=null && attach.getHeaders().size()>0){
  370.                         if(this.debug){
  371.                             this.log.debug("Dump "+attach.getHeaders().size()+" headers dell'allegato con id ["+attach.getContentId()+"]");
  372.                         }

  374.                         Map<String, List<String>> propertiesHdr = new HashMap<>();
  375.                         List<DumpHeaderAllegato> backupFailed = new ArrayList<DumpHeaderAllegato>();
  376.                                                 
  377.                         Iterator<String> keys = attach.getHeaders().keySet().iterator();
  378.                         while (keys.hasNext()) {
  379.                             String key = (String) keys.next();
  380.                             
  381.                             List<String> values = attach.getHeaders().get(key);
  382.                             if(values!=null && !values.isEmpty()) {
  383.                                 for (String value : values) {
  384.                                     if(value==null){
  385.                                         value = ""; // puo' succedere in alcuni casi.
  386.                                     }
  387.                                     if(this.debug){
  388.                                         this.log.debug("\t\t"+key+"="+value);
  389.                                     }
  390.         
  391.                                     DumpHeaderAllegato headerAllegato = new DumpHeaderAllegato();
  392.                                     headerAllegato.setNome(key);
  393.                                     headerAllegato.setValore(value.toString());
  394.                                     headerAllegato.setDumpTimestamp(gdo);
  395.                                     
  396.                                     if(headersCompact) {
  397.                                         TransportUtils.addHeader(propertiesHdr,key, value);
  398.                                         backupFailed.add(headerAllegato);
  399.                                     }
  400.                                     else {
  401.                                         dumpAllegato.addHeader(headerAllegato);
  402.                                     }
  403.                                 }
  404.                             }
  405.                         }
  406.                         
  407.                         if(headersCompact) {
  408.                             PropertiesSerializator ps = new PropertiesSerializator(propertiesHdr);
  409.                             try{
  410.                                 dumpAllegato.setHeaderExt(ps.convertToDBColumnValue());
  411.                                 backupFailed.clear();
  412.                                 backupFailed = null;
  413.                             }catch(Throwable e){
  414.                                 // NOTA: questo metodo dovrebbe non lanciare praticamente mai eccezione
  415.                                 this.log.error("Errore durante la conversione degli header dell'allegato '"+attach.getContentId()+"': "+e.getMessage(),e);
  416.                                 for (DumpHeaderAllegato dumpHeader : backupFailed) {
  417.                                     dumpAllegato.addHeader(dumpHeader);
  418.                                 }
  419.                             }
  420.                         }
  421.                     }
  422.                 }
  423.                     
  424.             }
  425.             
  426.             // CONTENUTI
  427.             if(messaggio.getContenuti()!=null && messaggio.getContenuti().size()>0){
  428.                 if(this.debug){
  429.                     this.log.debug("Dump "+messaggio.getContenuti().size()+" contenuti");
  430.                 }

  432.                 Iterator<String> keys = messaggio.getContenuti().keySet().iterator();
  433.                 while (keys.hasNext()) {
  434.                     String key = (String) keys.next();
  435.                     
  436.                     String value = messaggio.getContenuti().get(key);
  437.                     if(value==null){
  438.                         value = ""; // puo' succedere in alcuni casi.
  439.                     }

  441.                     DumpContenuto contenuto = TransactionContentUtils.createDumpContenuto(key, value, gdo); 
  442.                     
  443.                     if(this.debug){
  444.                         this.log.debug("\t\t"+key+"="+value);
  445.                     }
  446.                     
  447.                     dumpMessaggio.addContenuto(contenuto);
  448.                 }
  449.             }
  450.             
  451.             if(this.debug){
  452.                 this.log.debug("@@ log"+identificativoDump+" registrazione in corso ...");
  453.             }
  454.             
  455.             dumpMessageService.create(dumpMessaggio);
  456.             
  457.             if(fDump!=null) {
  458.                 
  459.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  460.                 sqlQueryObject.addUpdateTable(CostantiDB.DUMP_MESSAGGI);
  461.                 sqlQueryObject.addUpdateField("body", "?");
  462.                 sqlQueryObject.addWhereCondition(CostantiDB.DUMP_MESSAGGI+".id=?");
  463.                 
  464.                 IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.tipoDatabase);
  465.                 
  466.                 String sqlQueryUpdate =sqlQueryObject.createSQLUpdate();
  467.                 PreparedStatement pstmt = null;
  468.                 try {
  469.                     try(FileInputStream fin = new FileInputStream(fDump)){
  470.                         int index = 1;
  471.                         pstmt = con.prepareStatement(sqlQueryUpdate);
  472.                         jdbcAdapter.setBinaryData(pstmt, index++, fin, true);
  473.                         pstmt.setLong(index++, dumpMessaggio.getId());
  474.                         pstmt.execute();
  475.                     }
  476.                 }finally {
  477.                     try {
  478.                         if(pstmt!=null) {
  479.                             pstmt.close();
  480.                         }
  481.                     }catch(Exception eClose) {
  482.                         // close
  483.                     }
  484.                 }
  485.             }
  486.             
  487.             if(this.debug){
  488.                 this.log.debug("@@ log"+identificativoDump+" registrazione completata");
  489.             }

  491.         }catch(Exception e){
  492.             throw new DumpException("Errore durante il dump del messaggio idTransazione["+idTransazione+"] tipoMessaggio["+tipoMessaggio+"]: "+e.getMessage(),e);
  493.         }finally{
  494.             try{
  495.                 this.releaseConnection(cr, "dump.log");
  496.             }catch(Exception e){
  497.                 // close
  498.             }
  499.         }
  500.     }


  503. }
Created with JaCoCo 0.8.8.202204050719