SavedMessage.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.core;

  26. import java.io.ByteArrayInputStream;
  27. import java.io.File;
  28. import java.io.FileInputStream;
  29. import java.io.FileNotFoundException;
  30. import java.io.FileOutputStream;
  31. import java.io.InputStream;
  32. import java.nio.file.Files;
  33. import java.sql.Connection;
  34. import java.sql.PreparedStatement;
  35. import java.sql.ResultSet;
  36. import java.sql.SQLException;
  37. import java.sql.Timestamp;
  38. import java.util.Date;

  40. import org.openspcoop2.generic_project.exception.DeserializerException;
  41. import org.openspcoop2.message.OpenSPCoop2Message;
  42. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  43. import org.openspcoop2.message.OpenSPCoop2MessageParseResult;
  44. import org.openspcoop2.message.constants.MessageRole;
  45. import org.openspcoop2.message.constants.MessageType;
  46. import org.openspcoop2.message.context.MessageContext;
  47. import org.openspcoop2.message.context.SerializedContext;
  48. import org.openspcoop2.message.context.SerializedParameter;
  49. import org.openspcoop2.message.exception.MessageException;
  50. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  51. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  52. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  53. import org.openspcoop2.pdd.core.state.OpenSPCoopStateless;
  54. import org.openspcoop2.protocol.engine.constants.Costanti;
  55. import org.openspcoop2.protocol.sdk.Context;
  56. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  57. import org.openspcoop2.protocol.sdk.state.RequestInfoConfigUtilities;
  58. import org.openspcoop2.protocol.sdk.state.StateMessage;
  59. import org.openspcoop2.utils.LoggerWrapperFactory;
  60. import org.openspcoop2.utils.UtilsException;
  61. import org.openspcoop2.utils.beans.WriteToSerializerType;
  62. import org.openspcoop2.utils.io.notifier.NotifierInputStreamParams;
  63. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  64. import org.openspcoop2.utils.serialization.JavaDeserializer;
  65. import org.slf4j.Logger;


  68. /**
  69.  * Classe utilizzata per rappresentare un messaggio Soap nel contesto della libreria.
  70.  *
  71.  * @author Poli Andrea (apoli@link.it)
  72.  * @author Tronci Fabio (tronci@link.it)
  73.  * @author Lorenzo Nardi (nardi@link.it)
  74.  * @author $Author$
  75.  * @version $Rev$, $Date$
  76.  */



  80. public class SavedMessage implements java.io.Serializable {

  82.     /**
  83.      * serialVersionUID
  84.      */
  85.     private static final long serialVersionUID = 1L;

  87.     /** Logger utilizzato per debug. */
  88.     protected transient Logger internalLog = null;
  89.     private synchronized void initLog() {
  90.         if(this.internalLog==null) {
  91.             this.internalLog = LoggerWrapperFactory.getLogger(SavedMessage.class);
  92.         }
  93.     }
  94.     protected Logger getLog() {
  95.         if(this.internalLog==null) {
  96.             this.initLog();
  97.         }
  98.         return this.internalLog;
  99.     }

  101.     public static final String REST_CONTENT_TYPE_EMPTY = "____EMPTY____";
  102.     
  103.     private static final String MSG_BYTES = "_bytes.bin";
  104.     private static final String MSG_CONTEXT = "_context.bin";
  105.     private static final String MSG_RESPONSE_BYTES = "_response_bytes.bin";
  106.     private static final String MSG_RESPONSE_CONTEXT = "_response_context.bin";
  107.     private static final String MSG_TRANSACTION_CONTEXT = "_transaction_context.bin";


  110.     /* ********  F I E L D S  P R I V A T I  ******** */

  112.     /** Identificativo del Messaggio */
  113.     protected String idMessaggio;
  114.     /** Indicazione se il messaggio sara' salvato nella INBOX dei messaggi, o nella OUTBOX */
  115.     protected String box;
  116.     /** Indicazione se il messaggio deve essere registrato su file System o su DB */
  117.     protected boolean saveOnFS;
  118.     /** Identificativo del Messaggio passato sotto una funziona HASH */
  119.     protected String keyMsgBytes;
  120.     /** Identificativo del MessaggeContext passato sotto una funziona HASH */
  121.     protected String keyMsgContext;
  122.     /** Indica la directory dove effettuare salvataggi */
  123.     /** Identificativo del Messaggio passato sotto una funziona HASH */
  124.     protected String keyMsgResponseBytes;
  125.     /** Identificativo del MessageContext passato sotto una funziona HASH */
  126.     protected String keyMsgResponseContext;
  127.     /** Identificativo del TransactionContext passato sotto una funziona HASH */
  128.     protected String keyMsgTransactionContext;
  129.     /** Indica la directory dove effettuare salvataggi */
  130.     private String workDir;
  131.     /** AdapterJDBC */
  132.     protected transient IJDBCAdapter adapter;


  135.     protected transient IOpenSPCoopState openspcoopstate;

  137.     /** OpenSPCoopProperties */
  138.     private transient OpenSPCoop2Properties openspcoopProperties = OpenSPCoop2Properties.getInstance();




  143.     /* ********  C O S T R U T T O R E  ******** */
  144.     /**
  145.      * Costruttore. 
  146.      *
  147.      * @param idMsg ID del Messaggio
  148.      * @param openspcoopstate state Oggetto che rappresenta lo stato di una busta
  149.      * @param box Indicazione se il messaggio sara' salvato nella INBOX dei messaggi, o nella OUTBOX
  150.      * @param workDir Directory dove effettuare salvataggi se il messaggio deve essere registrato su FileSystem, null se il messaggio deve essere registrato su DB
  151.      * 
  152.      */
  153.     public SavedMessage(String idMsg, IOpenSPCoopState openspcoopstate, String box, String workDir,Logger alog) throws UtilsException{
  154.         this(idMsg, openspcoopstate ,box,workDir,null,alog);
  155.     }

  157.     /**
  158.      * Costruttore. 
  159.      *
  160.      * @param idMsg ID del Messaggio
  161.      * @param openspcoopstate state Oggetto che rappresenta lo stato di una busta
  162.      * @param box Indicazione se il messaggio sara' salvato nella INBOX dei messaggi, o nella OUTBOX
  163.      * @param adapterJDBC  JDBCAdapter se il messaggio deve essere registrato su DB, null se il messaggio deve essere registrato su file System 
  164.      * 
  165.      */
  166.     public SavedMessage(String idMsg, IOpenSPCoopState openspcoopstate, String box, IJDBCAdapter adapterJDBC,Logger alog) throws UtilsException{
  167.         this(idMsg, openspcoopstate ,box,null,adapterJDBC,alog);
  168.     }


  171.     /**
  172.      * Costruttore. 
  173.      *
  174.      * @param idMsg ID del Messaggio
  175.      * @param openspcoopstate state Oggetto che rappresenta lo stato di una busta
  176.      * @param box Indicazione se il messaggio sara' salvato nella INBOX dei messaggi, o nella OUTBOX
  177.      * @param workDir Directory dove effettuare salvataggi se il messaggio deve essere registrato su FileSystem, null se il messaggio deve essere registrato su DB
  178.      * @param adapterJDBC  JDBCAdapter se il messaggio deve essere registrato su DB, null se il messaggio deve essere registrato su file System 
  179.      * 
  180.      */
  181.     public SavedMessage(String idMsg, IOpenSPCoopState openspcoopstate, String box, String workDir, 
  182.             IJDBCAdapter adapterJDBC,Logger alog) throws UtilsException{
  183.         this.idMessaggio = idMsg;
  184.         this.box = box;
  185.         this.openspcoopstate = openspcoopstate;
  186.         if(alog!=null){
  187.             this.internalLog = alog;
  188.         }else{
  189.             this.internalLog = LoggerWrapperFactory.getLogger(SavedMessage.class);
  190.         }
  191.         try{

  193.             String hashKey = this.hash(idMsg);
  194.             if(hashKey == null){
  195.                 throw new UtilsException("Codifica hash non riuscita: keyMsgBytes is null");
  196.             }
  197.             
  198.             this.keyMsgBytes = hashKey + MSG_BYTES;
  199.             this.keyMsgResponseBytes = hashKey + MSG_RESPONSE_BYTES;

  201.             this.keyMsgContext = hashKey + MSG_CONTEXT;
  202.             this.keyMsgResponseContext = hashKey + MSG_RESPONSE_CONTEXT;
  203.             
  204.             this.keyMsgTransactionContext = hashKey + MSG_TRANSACTION_CONTEXT;

  206.         }catch(Exception e){
  207.             String errorMsg = "SOAP_MESSAGE, costructor error (CodificaHash): "+box+"/"+idMsg+": "+e.getMessage();      
  208.             this.getLog().error(errorMsg);
  209.             throw new UtilsException(errorMsg,e);
  210.         }

  212.         if(adapterJDBC==null){
  213.             this.saveOnFS = true;
  214.             this.workDir = workDir;
  215.         }else{
  216.             this.saveOnFS = false;
  217.             this.adapter = adapterJDBC;
  218.         }
  219.     }

  221.     /**
  222.      * Ritorna un intero che rappresenta la chiave di una stringa.
  223.      *
  224.      * @param key Stringa su cui effettuare la traduzione.
  225.      * @return hash della stringa.
  226.      * 
  227.      */
  228.     private String hash(String key) throws UtilsException{
  229.         try{
  230.             StringBuilder returnKey = new StringBuilder();
  231.             for(int i=0; i<key.length();i++){
  232.                 if( (key.charAt(i) != '_') && (key.charAt(i) != '-') &&
  233.                         (key.charAt(i) != '.') && (key.charAt(i) != ':') )
  234.                     returnKey.append(key.charAt(i));
  235.             }

  237.             return returnKey.toString();

  239.         } catch (java.lang.Exception e) {
  240.             throw new UtilsException("Utilities.hash error "+e.getMessage(),e);
  241.         }
  242.     }








  251.     /* ********  U T I L I T Y  ******** */

  253.     /**
  254.      * Ritorna la directory base su cui effettuare salvataggi 
  255.      *
  256.      * @return Ritorna la directory base su cui effettuare salvataggi 
  257.      * 
  258.      */
  259.     public String getBaseDir() throws UtilsException{

  261.         String prefix = "SOAP_MESSAGE, getBaseDir: "+this.box+"/"+this.idMessaggio;
  262.         
  263.         // Controllo esistenza directory fornita per salvare i messaggi
  264.         File dir = new File(this.workDir);
  265.         if(!dir.exists()){
  266.             String errorMsg = prefix+": directory di lavoro inesistente ("+this.workDir+").";       
  267.             this.getLog().error(errorMsg);
  268.             throw new UtilsException(errorMsg);
  269.         }
  270.         String baseDir = this.workDir;
  271.         if (!baseDir.endsWith(File.separator))
  272.             baseDir = baseDir + File.separator;

  274.         // Seleziono INBOX/OUTBOX
  275.         if(Costanti.INBOX.equals(this.box)){
  276.             baseDir = baseDir + Costanti.INBOX;
  277.         }else if (Costanti.OUTBOX.equals(this.box)){
  278.             baseDir = baseDir + Costanti.OUTBOX;
  279.         }else{
  280.             String errorMsg = prefix+": box non valido? .";     
  281.             this.getLog().error(errorMsg);
  282.             throw new UtilsException(errorMsg);
  283.         }

  285.         // Controllo esistenza di INBUX/OUTBOX
  286.         File dirINOUT = new File(baseDir);
  287.         if(!dirINOUT.exists() &&
  288.             !dirINOUT.mkdir()){
  289.             String errorMsg = prefix+": directory di lavoro ("+this.workDir+") non permette la creazione di sottodirectory INBOX/OUTBOX.";      
  290.             this.getLog().error(errorMsg);
  291.             throw new UtilsException(errorMsg);
  292.         }

  294.         return (baseDir+ File.separator);

  296.     }

  298.     /**
  299.      * Ritorna il codice del Messaggio
  300.      *
  301.      * @return Codice.
  302.      * 
  303.      */
  304.     public String getIdMessaggio(){
  305.         return this.idMessaggio;
  306.     }

  308.     /**
  309.      *Aggiorna lo stato
  310.      */
  311.     public void updateState(IOpenSPCoopState openspcoopstate){
  312.         this.openspcoopstate = openspcoopstate;
  313.     }
  314.     
  315.     protected void checkInizializzazioneWorkingDir(String saveDir) throws UtilsException {
  316.         if(saveDir==null){
  317.             String errorMsg = "WorkDir non correttamente inizializzata";        
  318.             throw new UtilsException(errorMsg);
  319.         }
  320.     }
  321.     
  322.     protected void checkInizializzazioneAdapter() throws UtilsException {
  323.         if(this.adapter==null) {
  324.             throw new UtilsException("Adapter unavailable");
  325.         }
  326.     }
  327.     
  328.     protected void logError(String errorMsg, Exception e) {
  329.         this.getLog().error(errorMsg,e);
  330.     }
  331.     
  332.     


  335.     /* ********  S A V E  ******** */

  337.     /**
  338.      * Dato un messaggio come parametro, si occupa di salvarlo nel filesystem/DB. 
  339.      * Il SoapEnvelope viene salvato nel FileSystem associandoci l'informazione strutturale <var>idMessaggio</var>.
  340.      *
  341.      *
  342.      * @param msg Messaggio.
  343.      * 
  344.      */
  345.     public void save(OpenSPCoop2Message msg, boolean isRichiesta, boolean portaDiTipoStateless, boolean consumeMessage, Timestamp oraRegistrazione) throws UtilsException{
  346.         SavedMessagePSUtilities.save(this, msg, isRichiesta, portaDiTipoStateless, consumeMessage, oraRegistrazione);
  347.     }     
  348.     protected void saveMessageBytes(String path,OpenSPCoop2Message msg, boolean consumeMessage, boolean overwrite) throws UtilsException{

  350.         FileOutputStream fos = null;
  351.         try{

  353.             File fileMsg = new File(path);
  354.             if(fileMsg.exists()){
  355.                 if(overwrite) {
  356.                     deleteMessageFile(fileMsg);
  357.                 }
  358.                 else {
  359.                     throw new UtilsException("L'identificativo del Messaggio risulta già registrato: "+path);
  360.                 }
  361.             }   

  363.             fos = new FileOutputStream(path);
  364.             // Scrittura Messaggio su FileSystem
  365.             msg.writeTo(fos,consumeMessage);
  366.             fos.close();

  368.         }catch(Exception e){
  369.             try{
  370.                 if( fos != null )
  371.                     fos.close();
  372.             } catch(Exception er) {
  373.                 // close
  374.             }
  375.             throw new UtilsException("Utilities.saveMessage error "+e.getMessage(),e);
  376.         }
  377.     }
  378.     protected void saveMessageContext(String path,OpenSPCoop2Message msg, boolean overwrite) throws UtilsException{

  380.         FileOutputStream fos = null;
  381.         try{

  383.             File fileMsg = new File(path);
  384.             if(fileMsg.exists()){
  385.                 if(overwrite) {
  386.                     deleteMessageFile(fileMsg);
  387.                 }
  388.                 else {
  389.                     throw new UtilsException("L'identificativo del Messaggio risulta gia' registrato: "+path);
  390.                 }
  391.             }   

  393.             fos = new FileOutputStream(path);
  394.             // Scrittura Messaggio su FileSystem
  395.             msg.serializeResourcesTo(fos);
  396.             fos.close();

  398.         }catch(Exception e){
  399.             try{
  400.                 if( fos != null )
  401.                     fos.close();
  402.             } catch(Exception er) {
  403.                 // close
  404.             }
  405.             throw new UtilsException("Utilities.saveMessageContext error "+e.getMessage(),e);
  406.         }
  407.     }
  408.     protected void saveTransactionContext(String path,SerializedContext sc, boolean overwrite) throws UtilsException{

  410.         FileOutputStream fos = null;
  411.         try{

  413.             File fileMsg = new File(path);
  414.             if(fileMsg.exists()){
  415.                 if(overwrite) {
  416.                     deleteMessageFile(fileMsg);
  417.                 }
  418.                 else {
  419.                     throw new UtilsException("L'identificativo del Messaggio risulta gia' registrato: "+path);
  420.                 }
  421.             }   

  423.             fos = new FileOutputStream(path);
  424.             // Scrittura Messaggio su FileSystem
  425.             sc.writeTo(fos, WriteToSerializerType.XML_JAXB);
  426.             fos.close();

  428.         }catch(Exception e){
  429.             try{
  430.                 if( fos != null )
  431.                     fos.close();
  432.             } catch(Exception er) {
  433.                 // close
  434.             }
  435.             throw new UtilsException("Utilities.saveTransactionContext error "+e.getMessage(),e);
  436.         }
  437.     }

  439.     
  440.     public void updateResponse(OpenSPCoop2Message msg, boolean consumeMessage) throws UtilsException{
  441.         SavedMessagePSUtilities.updateResponse(this, msg, consumeMessage);
  442.     } 
  443.     
  444.     public void updateTransactionContext(Context transactionContext) throws UtilsException{
  445.         RequestInfo requestInfoBackup = null;
  446.         java.util.Map<String,Object> dynamicContext = null;
  447.         try {
  448.             if(transactionContext!=null) {
  449.                 requestInfoBackup = RequestInfoConfigUtilities.normalizeRequestInfoBeforeSerialization(transactionContext);
  450.                 dynamicContext = org.openspcoop2.core.constants.Costanti.removeDynamicMap(transactionContext);
  451.             }
  452.             SavedMessagePSUtilities.updateTransactionContext(this, transactionContext);
  453.         }finally {
  454.             if(requestInfoBackup!=null) {
  455.                 RequestInfoConfigUtilities.restoreRequestInfoAfterSerialization(transactionContext, requestInfoBackup);
  456.             }
  457.             if(dynamicContext!=null) {
  458.                 transactionContext.put(org.openspcoop2.core.constants.Costanti.DYNAMIC_MAP_CONTEXT, dynamicContext);
  459.             }
  460.         }
  461.     } 
  462.     
  463.     private void deleteMessageFile(File fileMsg) throws UtilsException {
  464.         try {
  465.             Files.delete(fileMsg.toPath());
  466.         }catch(Exception e) {
  467.             throw new UtilsException("L'identificativo del Messaggio risulta già registrato e non eliminabile ("+fileMsg.getAbsolutePath()+"): "+e.getMessage(),e);
  468.         }
  469.     }



  473.     /* ********  R E A D  ******** */

  475.     /**
  476.      * Ritorna un messaggio che era stata precedentemente salvata nel filesystem/DB. 
  477.      *
  478.      * @return il messaggio precedentemente salvato
  479.      * 
  480.      */
  481.     public OpenSPCoop2Message read(boolean isRichiesta, boolean portaDiTipoStateless, Date oraRegistrazione) throws UtilsException {
  482.          return readEngine(isRichiesta, portaDiTipoStateless, oraRegistrazione, false, true, null);
  483.     }
  484.     public OpenSPCoop2Message readResponse(Date oraRegistrazione, boolean throwExceptionIfNotExists) throws UtilsException {
  485.          return readEngine(false, false, oraRegistrazione, true, throwExceptionIfNotExists, null);
  486.     }
  487.     public Context readTransactionContext(Date oraRegistrazione) throws UtilsException {
  488.         Context c = new Context();
  489.         readEngine(false, false, oraRegistrazione, false, true, c);
  490.         return c;
  491.     }
  492.     private OpenSPCoop2Message readEngine(boolean isRichiesta, boolean portaDiTipoStateless, Date oraRegistrazione, boolean readResponseField, boolean throwExceptionIfNotExists, Context readTransactionContext) throws UtilsException {

  494.         if( !portaDiTipoStateless ) {

  496.             Connection connectionDB = (isRichiesta) ? 
  497.                     ((StateMessage)this.openspcoopstate.getStatoRichiesta()).getConnectionDB() :
  498.                         ((StateMessage)this.openspcoopstate.getStatoRisposta()).getConnectionDB();

  500.             return readMessage(oraRegistrazione, readResponseField, throwExceptionIfNotExists, readTransactionContext, connectionDB);

  502.         }else { /** if ( portaDiTipoStateless ){ */
  503.             if (isRichiesta) return ((OpenSPCoopStateless)this.openspcoopstate).getRichiestaMsg();
  504.             else return ((OpenSPCoopStateless)this.openspcoopstate).getRispostaMsg();
  505.         }
  506.     }

  508.     private OpenSPCoop2Message readMessage(Date oraRegistrazione, boolean readResponseField, boolean throwExceptionIfNotExists, Context readTransactionContext, Connection connectionDB) throws UtilsException {
  509.         
  510.         if(readTransactionContext!=null && this.saveOnFS) {
  511.             fillTransactionContextFromFileSystem(readTransactionContext, true); // il transactionContext deve esistere sempre
  512.             return null;    
  513.         }
  514.         
  515.         OpenSPCoop2Message msg = null;
  516.         PreparedStatement pstmt = null;
  517.         ResultSet rs = null;
  518.         try{

  520.             String sql = buildReadStatement(oraRegistrazione, readResponseField, readTransactionContext);
  521.             
  522.             pstmt =  connectionDB.prepareStatement(sql);
  523.             initPreparedStatement(oraRegistrazione, pstmt);
  524.             rs = pstmt.executeQuery();
  525.             
  526.             msg = readMessage(rs, readResponseField, throwExceptionIfNotExists, readTransactionContext);

  528.             rs.close();
  529.             pstmt.close();

  531.         }catch(Exception e){
  532.             try{
  533.                 if( rs != null )
  534.                     rs.close();
  535.             } catch(Exception er) {
  536.                 // close
  537.             }
  538.             try{
  539.                 if( pstmt != null )
  540.                     pstmt.close();
  541.             } catch(Exception er) {
  542.                 // close
  543.             }
  544.             String errorMsg = "SOAP_MESSAGE, read: "+this.box+"/"+this.idMessaggio+": "+e.getMessage();     
  545.             logError(errorMsg, e);
  546.             throw new UtilsException(errorMsg,e);
  547.         }
  548.         
  549.         return msg;
  550.     }
  551.     
  552.     private void fillTransactionContextFromFileSystem(Context readTransactionContext, boolean throwExceptionIfNotExists) throws UtilsException {
  553.         String saveDir = getBaseDir();
  554.         checkInizializzazioneWorkingDir(saveDir);
  555.         
  556.         InputStream isContext = null;
  557.         try{
  558.         
  559.             // Lettura Message Context
  560.             isContext = readTransactionContextBytes(saveDir, throwExceptionIfNotExists, null);
  561.                                 
  562.             // CostruzioneMessaggio
  563.             if(isContext!=null) {
  564.                 fillTransactionContext(readTransactionContext, isContext);
  565.             }
  566.             
  567.         }catch(Exception e){
  568.             try{
  569.                 if( isContext != null )
  570.                     isContext.close();
  571.             } catch(Exception er) {
  572.                 // close
  573.             }
  574.             throw new UtilsException(e.getMessage(),e);
  575.         }
  576.         
  577.     }
  578.     
  579.     private String buildReadStatement(Date oraRegistrazione, boolean readResponseField, Context readTransactionContext) {
  580.         StringBuilder query = new StringBuilder();
  581.         if(readTransactionContext!=null) {
  582.             query.append("select TRANSACTION_CONTEXT ");
  583.         }
  584.         else {
  585.             String columnContentType = readResponseField ? "RESPONSE_CONTENT_TYPE" : "CONTENT_TYPE";
  586.             String columnMsgBytes = readResponseField ? "RESPONSE_MSG_BYTES" : "MSG_BYTES";
  587.             String columnMsgContext = readResponseField ? "RESPONSE_MSG_CONTEXT" : "MSG_CONTEXT";
  588.             
  589.             // Leggo proprieta' messaggio
  590.             if(this.saveOnFS)
  591.                 query.append("select "+columnContentType+" ");
  592.             else
  593.                 query.append("select "+columnContentType+","+columnMsgBytes+","+columnMsgContext+" ");
  594.         }
  595.         query.append("from ");
  596.         query.append(GestoreMessaggi.DEFINIZIONE_MESSAGGI);
  597.         query.append(" WHERE ");
  598.         if(oraRegistrazione!=null) {
  599.             query.append("(ORA_REGISTRAZIONE BETWEEN ? AND ?) AND ");
  600.         }
  601.         query.append("ID_MESSAGGIO = ? AND TIPO = ?");
  602.         
  603.         return query.toString();
  604.     }
  605.     
  606.     private void initPreparedStatement(Date oraRegistrazione, PreparedStatement pstmt) throws SQLException {
  607.         int index = 1;
  608.         
  609.         Timestamp leftValue = null;
  610.         Timestamp rightValue = null;
  611.         if(oraRegistrazione!=null) {
  612.             leftValue = new Timestamp(oraRegistrazione.getTime() - (1000*60*5));
  613.             rightValue = new Timestamp(oraRegistrazione.getTime() + (1000*60*5));
  614.             pstmt.setTimestamp(index++,leftValue);
  615.             pstmt.setTimestamp(index++,rightValue);
  616.         }
  617.         
  618.         pstmt.setString(index++,this.idMessaggio);
  619.         if(Costanti.INBOX.equals(this.box))
  620.             pstmt.setString(index,Costanti.INBOX);
  621.         else
  622.             pstmt.setString(index,Costanti.OUTBOX);
  623.     }
  624.     
  625.     private InputStream readMessageBytes(String contentType, String saveDir, boolean readResponseField, ResultSet rs) throws UtilsException, FileNotFoundException, SQLException {
  626.         if(contentType!=null && !"".equals(contentType)) {
  627.             if(this.saveOnFS){
  628.                 // READ FROM FILE SYSTEM
  629.                 String pathBytes = saveDir + (readResponseField ? this.keyMsgResponseBytes : this.keyMsgBytes);
  630.                 File fileCheckBytes = new File(pathBytes);
  631.                 if(!fileCheckBytes.exists()){
  632.                     String errorMsg = "Il messaggio non risulta gia' registrato ("+pathBytes+").";      
  633.                     throw new UtilsException(errorMsg);
  634.                 }      
  635.                 return new FileInputStream(pathBytes);
  636.             }else{
  637.                 // READ FROM DB
  638.                 this.checkInizializzazioneAdapter();
  639.                 return new java.io.ByteArrayInputStream(this.adapter.getBinaryData(rs,2));
  640.             }
  641.         }
  642.         return null;
  643.     }

  645.     private InputStream readBytesCheckNullable(String tipo, File fileCheckContext, boolean throwExceptionIfNotExists) throws UtilsException, FileNotFoundException {
  646.         if(!fileCheckContext.exists()){
  647.             if(throwExceptionIfNotExists) {
  648.                 String errorMsg = "Il messaggio ("+tipo+") non risulta gia' registrato ("+fileCheckContext.getAbsolutePath()+").";      
  649.                 throw new UtilsException(errorMsg);
  650.             }
  651.             else {
  652.                 return null;
  653.             }
  654.         }
  655.         return new FileInputStream(fileCheckContext);
  656.     }
  657.     private InputStream readBytesCheckNullable(String tipo, byte[]content, boolean throwExceptionIfNotExists) throws UtilsException {
  658.         if(content==null) {
  659.             if(throwExceptionIfNotExists) {
  660.                 String errorMsg = "Il messaggio ("+tipo+") non risulta gia' registrato.";       
  661.                 throw new UtilsException(errorMsg);
  662.             }
  663.             else {
  664.                 return null;
  665.             }
  666.         }
  667.         return new java.io.ByteArrayInputStream(content);
  668.     }
  669.     
  670.     private InputStream readContextBytes(String saveDir, boolean readResponseField, boolean throwExceptionIfNotExists, ResultSet rs) throws UtilsException, FileNotFoundException, SQLException {
  671.         if(this.saveOnFS){
  672.             // READ FROM FILE SYSTEM
  673.             String pathContext = saveDir + (readResponseField ? this.keyMsgResponseContext : this.keyMsgContext);
  674.             File fileCheckContext = new File(pathContext);
  675.             return readBytesCheckNullable("context", fileCheckContext, throwExceptionIfNotExists) ;
  676.         }else{
  677.             // READ FROM DB
  678.             this.checkInizializzazioneAdapter();
  679.             byte[]content = this.adapter.getBinaryData(rs,3);
  680.             return readBytesCheckNullable("context", content, throwExceptionIfNotExists);
  681.         }
  682.     }
  683.     
  684.     private InputStream readTransactionContextBytes(String saveDir, boolean throwExceptionIfNotExists, ResultSet rs) throws UtilsException, FileNotFoundException, SQLException {
  685.         if(this.saveOnFS){
  686.             // READ FROM FILE SYSTEM
  687.             String pathContext = saveDir + this.keyMsgTransactionContext;
  688.             File fileCheckContext = new File(pathContext);
  689.             return readBytesCheckNullable("transaction context", fileCheckContext, throwExceptionIfNotExists) ;
  690.         }else{
  691.             // READ FROM DB
  692.             this.checkInizializzazioneAdapter();
  693.             byte[]content = this.adapter.getBinaryData(rs,1);
  694.             return readBytesCheckNullable("transaction context", content, throwExceptionIfNotExists);
  695.         }
  696.     }
  697.     
  698.     private OpenSPCoop2Message readMessage(ResultSet rs, boolean readResponseField, boolean throwExceptionIfNotExists, Context readTransactionContext) throws UtilsException, SQLException {
  699.         if(rs==null){
  700.             String errorMsg = "ResultSet is null?";     
  701.             throw new UtilsException(errorMsg);
  702.         }
  703.         if(!rs.next()){
  704.             String errorMsg = "Messaggio non esistente";        
  705.             throw new UtilsException(errorMsg);
  706.         }

  708.         OpenSPCoop2Message msg = null;
  709.         if(readTransactionContext!=null) {
  710.             fillTransactionContext(rs, readTransactionContext, true); // il transactionContext deve esistere sempre
  711.         }
  712.         else {
  713.             msg = readMessage(rs, readResponseField, throwExceptionIfNotExists);
  714.         }
  715.         return msg;
  716.     }
  717.     
  718.     private void fillTransactionContext(ResultSet rs, Context readTransactionContext, boolean throwExceptionIfNotExists) throws UtilsException {
  719.         InputStream isContext = null;
  720.         try{
  721.         
  722.             // Lettura Message Context
  723.             isContext = readTransactionContextBytes(null, throwExceptionIfNotExists, rs);
  724.                                 
  725.             // CostruzioneMessaggio
  726.             if(isContext!=null) {
  727.                 fillTransactionContext(readTransactionContext, isContext);
  728.             }
  729.             
  730.         }catch(Exception e){
  731.             try{
  732.                 if( isContext != null )
  733.                     isContext.close();
  734.             } catch(Exception er) {
  735.                 // close
  736.             }
  737.             throw new UtilsException(e.getMessage(),e);
  738.         }
  739.     }
  740.     
  741.     private OpenSPCoop2Message readMessage(ResultSet rs, boolean readResponseField, boolean throwExceptionIfNotExists) throws UtilsException, SQLException {
  742.         String saveDir = null;
  743.         if(this.saveOnFS){
  744.             // READ FROM FILE SYSTEM
  745.             
  746.             saveDir = getBaseDir();
  747.             checkInizializzazioneWorkingDir(saveDir);
  748.         }
  749.         
  750.         InputStream isBytes = null;
  751.         InputStream isContext = null;
  752.         try{
  753.         
  754.             // Lettura Message Context
  755.             isContext = readContextBytes(saveDir, readResponseField, throwExceptionIfNotExists, rs);
  756.             if(isContext==null) {
  757.                 // viene lanciata una eccezione prima se throwExceptionIfNotExists
  758.                 return null;
  759.             }
  760.             
  761.             // ContentType
  762.             String columnContentType = readResponseField ? "RESPONSE_CONTENT_TYPE" : "CONTENT_TYPE";
  763.             String contentType = rs.getString(columnContentType);
  764.             
  765.             // Costruzione MessageContext
  766.             SavedMessageContext smc = buildMessageContext(contentType, isContext);
  767.             contentType = smc.contentTypeNormalized;
  768.             
  769.             // Lettura Message Bytes
  770.             isBytes = readMessageBytes(contentType, saveDir, readResponseField, rs);
  771.                 
  772.             // CostruzioneMessaggio
  773.             return buildMessage(smc, contentType, isBytes);
  774.             
  775.         }catch(Exception e){
  776.             try{
  777.                 if( isBytes != null )
  778.                     isBytes.close();
  779.             } catch(Exception er) {
  780.                 // close
  781.             }
  782.             try{
  783.                 if( isContext != null )
  784.                     isContext.close();
  785.             } catch(Exception er) {
  786.                 // close
  787.             }
  788.             throw new UtilsException(e.getMessage(),e);
  789.         }
  790.     }
  791.     
  792.     private SavedMessageContext buildMessageContext(String contentType, InputStream isContext) throws UtilsException, DeserializerException {
  793.         org.openspcoop2.message.context.utils.serializer.JaxbDeserializer jaxbDeserializer  = 
  794.                 new org.openspcoop2.message.context.utils.serializer.JaxbDeserializer();
  795.         MessageContext msgContext = jaxbDeserializer.readMessageContext(isContext);
  796.         
  797.         if(msgContext.getMessageType()==null) {
  798.             throw new UtilsException("Message Type undefined in context serialized");
  799.         }
  800.         MessageType mt = MessageType.valueOf(msgContext.getMessageType());
  801.         if(mt==null) {
  802.             throw new UtilsException("MessageType ["+msgContext.getMessageType()+"] unknown");
  803.         }
  804.         
  805.         if(msgContext.getMessageRole()==null) {
  806.             throw new UtilsException("Message Role undefined in context serialized");
  807.         }
  808.         MessageRole mr = MessageRole.valueOf(msgContext.getMessageRole());
  809.         if(mr==null) {
  810.             throw new UtilsException("MessageRole ["+msgContext.getMessageRole()+"] unknown");
  811.         }
  812.         
  813.         if(MessageType.BINARY.equals(mt) &&
  814.                 REST_CONTENT_TYPE_EMPTY.equals(contentType)) {
  815.             contentType = null;
  816.         }
  817.         
  818.         SavedMessageContext smc = new SavedMessageContext();
  819.         smc.msgContext = msgContext;
  820.         smc.mt = mt;
  821.         smc.mr = mr;
  822.         smc.contentTypeNormalized = contentType;
  823.         return smc;
  824.     }
  825.     
  826.     private OpenSPCoop2Message buildMessage(SavedMessageContext smc, String contentType, InputStream isBytes) throws MessageException {
  827.         
  828.         OpenSPCoop2MessageFactory mf = OpenSPCoop2MessageFactory.getDefaultMessageFactory();
  829.         NotifierInputStreamParams notifierInputStreamParams = null; // Non dovrebbe servire, un eventuale handler attaccato, dovrebbe gia aver ricevuto tutto il contenuto una volta serializzato il messaggio su database.
  830.         OpenSPCoop2MessageParseResult pr = null;
  831.         pr = mf.createMessage(smc.mt,smc.mr,contentType,
  832.                 isBytes,notifierInputStreamParams,
  833.                 this.openspcoopProperties.getAttachmentsProcessingMode());
  834.         try {
  835.             OpenSPCoop2Message msg = pr.getMessage_throwParseException();
  836.             msg.readResourcesFrom(smc.msgContext);
  837.             return msg;
  838.         }catch(Exception e) {
  839.             throw new MessageException(e.getMessage(),e);
  840.         }
  841.     }

  843.     private void fillTransactionContext(Context context, InputStream is) throws UtilsException {
  844.         SerializedContext serializedContext = null;
  845.         try {
  846.             org.openspcoop2.message.context.utils.serializer.JaxbDeserializer deserializer = 
  847.                     new org.openspcoop2.message.context.utils.serializer.JaxbDeserializer();
  848.             serializedContext = deserializer.readSerializedContext(is);
  849.             
  850.             if(serializedContext!=null && serializedContext.sizePropertyList()>0) {
  851.                 JavaDeserializer jDeserializer = new JavaDeserializer();
  852.                 for (SerializedParameter p : serializedContext.getPropertyList()) {
  853.                     Object o = jDeserializer.readObject(new ByteArrayInputStream(p.getBase()), Class.forName(p.getClasse()));
  854.                     context.addObject(org.openspcoop2.utils.Map.newMapKey(p.getNome()), o);
  855.                 }
  856.             }
  857.             
  858.         }catch(Exception e) {
  859.             throw new UtilsException(e.getMessage(),e);
  860.         }   
  861.     }








  870.     /* ********  D E L E T E  ******** */

  872.     /**
  873.      * Elimina un messaggio completamente, sia dal filesystem che dal db 
  874.      * 
  875.      * 
  876.      */
  877.     public void delete(boolean isRichiesta,boolean onewayVersione11, java.sql.Timestamp data) throws UtilsException{
  878.         if((this.openspcoopstate instanceof OpenSPCoopStateful) || onewayVersione11) {
  879.             StateMessage stateMSG = (isRichiesta) ?  (StateMessage)this.openspcoopstate.getStatoRichiesta() 
  880.                     : (StateMessage)this.openspcoopstate.getStatoRisposta();
  881.             Connection connectionDB = stateMSG.getConnectionDB();

  883.             deleteStateful(connectionDB, data);
  884.             
  885.         }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  886.             // NOP
  887.         }else{
  888.             throw new UtilsException("Metodo invocato con IState non valido");
  889.         }
  890.     }
  891.     
  892.     private void deleteStateful(Connection connectionDB, java.sql.Timestamp data) throws UtilsException {
  893.         PreparedStatement pstmt = null;
  894.         try{
  895.             // Eliminazione da FileSystem
  896.             if(this.saveOnFS){
  897.                 deleteFileSystem();
  898.             }

  900.             //  Eliminazione from DB.
  901.             String sql = buildDeleteStatement(data);
  902.             pstmt= connectionDB.prepareStatement(sql);
  903.             pstmt.setString(1,this.idMessaggio);
  904.             if(Costanti.INBOX.equals(this.box))
  905.                 pstmt.setString(2,Costanti.INBOX);
  906.             else
  907.                 pstmt.setString(2,Costanti.OUTBOX);
  908.             if(data!=null) {
  909.                 pstmt.setTimestamp(3, data);
  910.             }
  911.             pstmt.execute();
  912.             pstmt.close();

  914.         }catch(Exception e){
  915.             try{
  916.                 if( pstmt != null )
  917.                     pstmt.close();
  918.             } catch(Exception er) {
  919.                 // close
  920.             }
  921.             String errorMsg = "SOAP_MESSAGE, delete: "+this.box+"/"+this.idMessaggio+": "+e.getMessage();       
  922.             logError(errorMsg,e);
  923.             throw new UtilsException(errorMsg,e);
  924.         }
  925.     }
  926.     
  927.     private String buildDeleteStatement(java.sql.Timestamp data) {
  928.         StringBuilder query = new StringBuilder();
  929.         query.append("DELETE from ");
  930.         query.append(GestoreMessaggi.DEFINIZIONE_MESSAGGI);
  931.         query.append(" WHERE ");
  932.         query.append(GestoreMessaggi.DEFINIZIONE_MESSAGGI_COLUMN_ID_MESSAGGIO);
  933.         query.append(" = ? AND ");
  934.         query.append(GestoreMessaggi.DEFINIZIONE_MESSAGGI_COLUMN_TIPO_MESSAGGIO);
  935.         query.append(" = ?");       
  936.         if(data!=null) {
  937.             query.append(" AND ");
  938.             query.append(GestoreMessaggi.DEFINIZIONE_MESSAGGI_COLUMN_ORA_REGISTRAZIONE);
  939.             query.append("<=?");
  940.         }
  941.         return query.toString();
  942.     }
  943.     
  944.     /**
  945.      * Elimina un messaggio completamente filesystem
  946.      * 
  947.      * 
  948.      */
  949.     public void deleteMessageFromFileSystem() {


  952.         try{
  953.             // Eliminazione da FileSystem
  954.             if(this.saveOnFS){
  955.                 
  956.                 deleteFileSystem();
  957.                 
  958.             }

  960.         }catch(Exception e){
  961.             String errorMsg = "SOAP_MESSAGE, deleteMessageFromFileSystem: "+this.box+"/"+this.idMessaggio+": "+e.getMessage();      
  962.             this.getLog().error(errorMsg,e);
  963.         }
  964.     }
  965.     
  966.     private void deleteFileSystem() throws UtilsException {
  967.         
  968.         String saveDir = getBaseDir();
  969.         checkInizializzazioneWorkingDir(saveDir);
  970.         
  971.         String pathBytes = saveDir + this.keyMsgBytes;
  972.         File fileDeleteBytes = new File(pathBytes);
  973.         if(fileDeleteBytes.exists()){
  974.             deleteFileIgnoreException(fileDeleteBytes);
  975.         }   
  976.                         
  977.         String pathContext = saveDir + this.keyMsgContext;
  978.         File fileDeleteContext = new File(pathContext);
  979.         if(fileDeleteContext.exists()){
  980.             deleteFileIgnoreException(fileDeleteContext);
  981.         }
  982.         
  983.         String pathResponseBytes = saveDir + this.keyMsgResponseBytes;
  984.         File fileDeleteResponseBytes = new File(pathResponseBytes);
  985.         if(fileDeleteResponseBytes.exists()){
  986.             deleteFileIgnoreException(fileDeleteResponseBytes);
  987.         }
  988.         
  989.         String pathResponseContext = saveDir + this.keyMsgResponseContext;
  990.         File fileDeleteResponseContext = new File(pathResponseContext);
  991.         if(fileDeleteResponseContext.exists()){
  992.             deleteFileIgnoreException(fileDeleteResponseContext);
  993.         }
  994.         
  995.         String pathTransactionContext = saveDir + this.keyMsgTransactionContext;
  996.         File fileDeleteTransactionContext = new File(pathTransactionContext);
  997.         if(fileDeleteTransactionContext.exists()){
  998.             deleteFileIgnoreException(fileDeleteTransactionContext);
  999.         }
  1000.         
  1001.     }

  1003.     
  1004.     private void deleteFileIgnoreException(File file) {
  1005.         try {
  1006.             Files.delete(file.toPath());
  1007.         }catch(Exception e) {
  1008.             // ignore
  1009.         }
  1010.     }
  1011. }

  1013. class SavedMessageContext {
  1014.     
  1015.     MessageContext msgContext;
  1016.     MessageType mt;
  1017.     MessageRole mr;
  1018.     String contentTypeNormalized;
  1019.     
  1020. }


Created with JaCoCo 0.8.8.202204050719