SavedMessagePSUtilities.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.ByteArrayOutputStream;
  27. import java.io.IOException;
  28. import java.io.Serializable;
  29. import java.sql.Connection;
  30. import java.sql.PreparedStatement;
  31. import java.sql.SQLException;
  32. import java.sql.Timestamp;

  34. import org.openspcoop2.message.OpenSPCoop2Message;
  35. import org.openspcoop2.message.constants.MessageType;
  36. import org.openspcoop2.message.constants.ServiceBinding;
  37. import org.openspcoop2.message.context.SerializedContext;
  38. import org.openspcoop2.message.context.SerializedParameter;
  39. import org.openspcoop2.message.exception.MessageException;
  40. import org.openspcoop2.message.exception.MessageNotSupportedException;
  41. import org.openspcoop2.pdd.core.state.OpenSPCoopStateless;
  42. import org.openspcoop2.protocol.engine.constants.Costanti;
  43. import org.openspcoop2.protocol.sdk.Context;
  44. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  45. import org.openspcoop2.protocol.sdk.state.RequestInfoConfigUtilities;
  46. import org.openspcoop2.protocol.sdk.state.StateMessage;
  47. import org.openspcoop2.utils.MapKey;
  48. import org.openspcoop2.utils.UtilsException;
  49. import org.openspcoop2.utils.beans.WriteToSerializerType;
  50. import org.openspcoop2.utils.serialization.JavaSerializer;


  53. /**
  54.  * SavedMessagePSUtilities
  55.  *
  56.  * @author Poli Andrea (apoli@link.it)
  57.  * @author Tronci Fabio (tronci@link.it)
  58.  * @author Lorenzo Nardi (nardi@link.it)
  59.  * @author $Author$
  60.  * @version $Rev$, $Date$
  61.  */



  65. public class SavedMessagePSUtilities {
  66.     
  67.     private SavedMessagePSUtilities() {}

  69.     public static void save(SavedMessage savedMessage,
  70.             OpenSPCoop2Message msg, boolean isRichiesta, boolean portaDiTipoStateless, boolean consumeMessage, Timestamp oraRegistrazione) throws UtilsException{

  72.         if( !portaDiTipoStateless ) {
  73.             StateMessage stateMsg = (isRichiesta) ?  
  74.                     (StateMessage)savedMessage.openspcoopstate.getStatoRichiesta() :
  75.                         (StateMessage)savedMessage.openspcoopstate.getStatoRisposta();
  76.             Connection connectionDB = stateMsg.getConnectionDB();

  78.             saveStateful(savedMessage, 
  79.                     msg, consumeMessage, oraRegistrazione,
  80.                     connectionDB, stateMsg);
  81.             
  82.         }else { /** if (portaDiTipoStateless){ */

  84.             if (isRichiesta) ((OpenSPCoopStateless)savedMessage.openspcoopstate).setRichiestaMsg(msg);
  85.             else ((OpenSPCoopStateless)savedMessage.openspcoopstate).setRispostaMsg(msg);


  88.         }

  90.     }  
  91.     
  92.     private static void saveStateful(SavedMessage savedMessage, 
  93.             OpenSPCoop2Message msg, boolean consumeMessage, Timestamp oraRegistrazione,
  94.             Connection connectionDB, StateMessage stateMsg) throws UtilsException {
  95.         PreparedStatement pstmt = null;
  96.         try{
  97.             // Save proprieta' msg
  98.             StringBuilder query = new StringBuilder();
  99.             query.append("INSERT INTO  ");
  100.             query.append(GestoreMessaggi.DEFINIZIONE_MESSAGGI);
  101.             if(savedMessage.saveOnFS)
  102.                 query.append(" (ID_MESSAGGIO,TIPO,CONTENT_TYPE,ORA_REGISTRAZIONE) VALUES ( ? , ? , ? , ? )");
  103.             else
  104.                 query.append(" (ID_MESSAGGIO,TIPO,CONTENT_TYPE,ORA_REGISTRAZIONE,MSG_BYTES,MSG_CONTEXT) VALUES ( ? , ? , ? , ? , ? , ?)");

  106.             pstmt = connectionDB.prepareStatement(query.toString());
  107.             pstmt.setString(1,savedMessage.idMessaggio);
  108.             if(Costanti.INBOX.equals(savedMessage.box))
  109.                 pstmt.setString(2,Costanti.INBOX);
  110.             else
  111.                 pstmt.setString(2,Costanti.OUTBOX);     

  113.             //Sposto il set del contentType dopo la writeTo del messaggio 
  114.             //cosi nel caso di attachment lo trovo corretto.

  116.             saveNormalizeRequestInfoBeforeSerialization(savedMessage,
  117.                     msg, consumeMessage,
  118.                     pstmt);

  120.             // Set del contentType nella query
  121.             String contentType = readContentType(msg);
  122.             pstmt.setString(3,contentType);
  123.             
  124.             // Set Ora Registrazione
  125.             pstmt.setTimestamp(4,oraRegistrazione);

  127.             // Add PreparedStatement
  128.             stateMsg.getPreparedStatement().put("INSERT (MSG_OP_STEP1a) saveMessage["+savedMessage.idMessaggio+","+savedMessage.box+"]",pstmt);

  130.         }catch(Exception e){
  131.             try{
  132.                 if( pstmt != null )
  133.                     pstmt.close();
  134.             } catch(Exception err) {
  135.                 // close
  136.             }
  137.             String errorMsg = "SOAP_MESSAGE, save : "+savedMessage.box+"/"+savedMessage.idMessaggio+": "+e.getMessage();        
  138.             savedMessage.logError(errorMsg,e);
  139.             throw new UtilsException(errorMsg,e);
  140.         }
  141.     }
  142.     
  143.     private static void saveNormalizeRequestInfoBeforeSerialization(SavedMessage savedMessage,
  144.             OpenSPCoop2Message msg, boolean consumeMessage,
  145.             PreparedStatement pstmt) throws UtilsException, MessageException, IOException, SQLException {
  146.         // Elimino dalla RequestInfo i dati "cached"
  147.         RequestInfo requestInfoBackup = RequestInfoConfigUtilities.normalizeRequestInfoBeforeSerialization(msg);
  148.         try {
  149.             save(savedMessage,
  150.                     msg, consumeMessage,
  151.                     pstmt);
  152.         }finally {
  153.             if(requestInfoBackup!=null) {
  154.                 RequestInfoConfigUtilities.restoreRequestInfoAfterSerialization(msg, requestInfoBackup);
  155.             }
  156.         }
  157.     }
  158.     private static void save(SavedMessage savedMessage,
  159.             OpenSPCoop2Message msg, boolean consumeMessage,
  160.             PreparedStatement pstmt) throws UtilsException, MessageException, IOException, SQLException {
  161.         if(savedMessage.saveOnFS){
  162.             // SAVE IN FILE SYSTEM
  163.             
  164.             String saveDir = savedMessage.getBaseDir();
  165.             savedMessage.checkInizializzazioneWorkingDir(saveDir);
  166.             
  167.             // Save bytes message
  168.             String pathBytes = saveDir + savedMessage.keyMsgBytes;
  169.             savedMessage.saveMessageBytes(pathBytes,msg, consumeMessage,false);
  170.             
  171.             // Save message context
  172.             String pathContext = saveDir + savedMessage.keyMsgContext;
  173.             savedMessage.saveMessageContext(pathContext,msg,false);
  174.             
  175.         }else{
  176.             // SAVE IN DB
  177.             
  178.             // Save bytes message
  179.             java.io.ByteArrayOutputStream bout = new java.io.ByteArrayOutputStream();
  180.             msg.writeTo(bout,consumeMessage);
  181.             bout.flush();
  182.             bout.close();
  183.             /** System.out.println("---------SALVO RISPOSTA: "+msgByte.toString()); */
  184.             savedMessage.adapter.setBinaryData(pstmt,5,bout.toByteArray());
  185.             
  186.             // Save message context
  187.             bout = new java.io.ByteArrayOutputStream();
  188.             msg.serializeResourcesTo(bout);
  189.             bout.flush();
  190.             bout.close();
  191.             /** System.out.println("---------SALVO CONTEXT: "+msgByte.toString()); */
  192.             savedMessage.adapter.setBinaryData(pstmt,6,bout.toByteArray());
  193.         }
  194.     }
  195.     private static String readContentType(OpenSPCoop2Message msg) throws UtilsException, MessageException, MessageNotSupportedException {
  196.         
  197.         String prefix = "Rilevata una richiesta "+msg.getServiceBinding();
  198.         
  199.         String contentType = msg.getContentType();
  200.         if(contentType==null || "".equals(contentType)){
  201.             if(ServiceBinding.REST.equals(msg.getServiceBinding())){
  202.                 if(MessageType.BINARY.equals(msg.getMessageType())) {
  203.                     if(msg.castAsRest().hasContent()) {
  204.                         throw new UtilsException(prefix+" "+msg.getMessageType()+" con payload per la quale non è stato fornito un ContentType"); // sul DB e' required la colonna
  205.                     }
  206.                     else {
  207.                         contentType = SavedMessage.REST_CONTENT_TYPE_EMPTY;
  208.                     }
  209.                 }
  210.                 else {
  211.                     throw new UtilsException(prefix+" "+msg.getMessageType()+" per la quale non è stato fornito un ContentType"); // sul DB e' required la colonna
  212.                 }
  213.             }
  214.             else {
  215.                 throw new UtilsException(prefix+" per la quale non è stato fornito un ContentType"); // sul DB e' required la colonna
  216.             }
  217.         }
  218.         return contentType;
  219.     }

  221.     
  222.     public static void updateResponse(SavedMessage savedMessage,
  223.             OpenSPCoop2Message msg, boolean consumeMessage) throws UtilsException{

  225.         StateMessage stateMsg = (StateMessage)savedMessage.openspcoopstate.getStatoRisposta();
  226.         Connection connectionDB = stateMsg.getConnectionDB();

  228.         PreparedStatement pstmt = null;
  229.         try{
  230.             // Save proprieta' msg
  231.             StringBuilder query = new StringBuilder();
  232.             query.append("UPDATE ");
  233.             query.append(GestoreMessaggi.DEFINIZIONE_MESSAGGI);
  234.             query.append(" SET ");
  235.             query.append(" RESPONSE_CONTENT_TYPE=? ");
  236.             if(!savedMessage.saveOnFS) {
  237.                 query.append(" , RESPONSE_MSG_BYTES=? ");
  238.                 query.append(" , RESPONSE_MSG_CONTEXT=? ");
  239.             }
  240.             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");


  243.             pstmt = connectionDB.prepareStatement(query.toString());
  244.             int index = 1;
  245.             
  246.             // Set del contentType nella query
  247.             String contentType = readContentType(msg);
  248.             pstmt.setString(index++,contentType);
  249.             
  250.             index = updateResponseNormalizeRequestInfoBeforeSerialization(savedMessage,
  251.                     msg, consumeMessage,
  252.                     pstmt, index);
  253.             
  254.             pstmt.setString(index++,savedMessage.idMessaggio);
  255.             if(Costanti.INBOX.equals(savedMessage.box))
  256.                 pstmt.setString(index,Costanti.INBOX);
  257.             else
  258.                 pstmt.setString(index,Costanti.OUTBOX);     


  261.             // Add PreparedStatement
  262.             stateMsg.getPreparedStatement().put("UPDATE (RESPONSE) saveMessage["+savedMessage.idMessaggio+","+savedMessage.box+"]",pstmt);
  263.     
  264.         }catch(Exception e){
  265.             try{
  266.                 if( pstmt != null )
  267.                     pstmt.close();
  268.             } catch(Exception err) {
  269.                 // close
  270.             }
  271.             String errorMsg = "SOAP_MESSAGE, update response : "+savedMessage.box+"/"+savedMessage.idMessaggio+": "+e.getMessage();     
  272.             savedMessage.logError(errorMsg,e);
  273.             throw new UtilsException(errorMsg,e);
  274.         }

  276.     }     
  277.     
  278.     private static int updateResponseNormalizeRequestInfoBeforeSerialization(SavedMessage savedMessage,
  279.             OpenSPCoop2Message msg, boolean consumeMessage,
  280.             PreparedStatement pstmt, int index) throws UtilsException, MessageException, IOException, SQLException {
  281.         // Elimino dalla RequestInfo i dati "cached"
  282.         RequestInfo requestInfoBackup = RequestInfoConfigUtilities.normalizeRequestInfoBeforeSerialization(msg);
  283.         try {
  284.             return updateResponse(savedMessage,
  285.                     msg, consumeMessage,
  286.                     pstmt, index);
  287.         }finally {
  288.             if(requestInfoBackup!=null) {
  289.                 RequestInfoConfigUtilities.restoreRequestInfoAfterSerialization(msg, requestInfoBackup);
  290.             }
  291.         }
  292.     }
  293.     private static int updateResponse(SavedMessage savedMessage,
  294.             OpenSPCoop2Message msg, boolean consumeMessage,
  295.             PreparedStatement pstmt, int index) throws UtilsException, MessageException, IOException, SQLException {
  296.         if(savedMessage.saveOnFS){
  297.             // SAVE IN FILE SYSTEM
  298.             
  299.             String saveDir = savedMessage.getBaseDir();
  300.             savedMessage.checkInizializzazioneWorkingDir(saveDir);
  301.             
  302.             // Save bytes message
  303.             String pathBytes = saveDir + savedMessage.keyMsgResponseBytes;
  304.             savedMessage.saveMessageBytes(pathBytes,msg, consumeMessage, false);
  305.             
  306.             // Save message context
  307.             String pathContext = saveDir + savedMessage.keyMsgResponseContext;
  308.             savedMessage.saveMessageContext(pathContext,msg, false);
  309.             
  310.         }else{
  311.             // SAVE IN DB
  312.             
  313.             // Save bytes message
  314.             java.io.ByteArrayOutputStream bout = new java.io.ByteArrayOutputStream();
  315.             msg.writeTo(bout,consumeMessage);
  316.             bout.flush();
  317.             bout.close();
  318.             /** System.out.println("---------SALVO RISPOSTA: "+msgByte.toString()); */
  319.             savedMessage.adapter.setBinaryData(pstmt,index++,bout.toByteArray());
  320.             
  321.             // Save message context
  322.             bout = new java.io.ByteArrayOutputStream();
  323.             msg.serializeResourcesTo(bout);
  324.             bout.flush();
  325.             bout.close();
  326.             /** System.out.println("---------SALVO CONTEXT: "+msgByte.toString()); */
  327.             savedMessage.adapter.setBinaryData(pstmt,index++,bout.toByteArray());
  328.         }
  329.         return index;
  330.     }
  331.     
  332.     
  333.     
  334.     
  335.     
  336.     
  337.     
  338.     public static void updateTransactionContext(SavedMessage savedMessage,Context transactionContext) throws UtilsException{

  340.         if(transactionContext==null || transactionContext.isEmpty()) {
  341.             return;
  342.         }
  343.         
  344.         SerializedContext sc = buildSerializedContext(transactionContext);
  345.         
  346.         if(savedMessage.saveOnFS) {
  347.             
  348.             String saveDir = savedMessage.getBaseDir();
  349.             savedMessage.checkInizializzazioneWorkingDir(saveDir);
  350.             
  351.             // Save bytes message
  352.             String pathBytes = saveDir + savedMessage.keyMsgTransactionContext;
  353.             savedMessage.saveTransactionContext(pathBytes,sc, false);
  354.             
  355.         }
  356.         else {
  357.         
  358.             StateMessage stateMsg = (StateMessage)savedMessage.openspcoopstate.getStatoRisposta();
  359.             Connection connectionDB = stateMsg.getConnectionDB();
  360.     
  361.             // Save proprieta' msg
  362.             StringBuilder query = new StringBuilder();
  363.             query.append("UPDATE ");
  364.             query.append(GestoreMessaggi.DEFINIZIONE_MESSAGGI);
  365.             query.append(" SET ");
  366.             query.append(" TRANSACTION_CONTEXT=? ");
  367.             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");
  368.             
  369.             try (PreparedStatement pstmt = connectionDB.prepareStatement(query.toString());){
  370.                 int index = 1;
  371.                 
  372.                 java.io.ByteArrayOutputStream bout = new java.io.ByteArrayOutputStream();
  373.                 sc.writeTo(bout, WriteToSerializerType.XML_JAXB);
  374.                 bout.flush();
  375.                 bout.close();
  376.                 
  377.                 /** System.out.println("---------SALVO TRANSACTION CONTEXT: "+msgByte.toString()); */
  378.                 savedMessage.adapter.setBinaryData(pstmt,index++,bout.toByteArray());
  379.                 
  380.                 pstmt.setString(index++,savedMessage.idMessaggio);
  381.                 if(Costanti.INBOX.equals(savedMessage.box))
  382.                     pstmt.setString(index,Costanti.INBOX);
  383.                 else
  384.                     pstmt.setString(index,Costanti.OUTBOX);     
  385.                 
  386.                 pstmt.executeUpdate();
  387.         
  388.             }catch(Exception e){
  389.                 String errorMsg = "SOAP_MESSAGE, update transaction context : "+savedMessage.box+"/"+savedMessage.idMessaggio+": "+e.getMessage();      
  390.                 savedMessage.logError(errorMsg,e);
  391.                 throw new UtilsException(errorMsg,e);
  392.             }
  393.             
  394.         }

  396.     }  
  397.     private static SerializedContext buildSerializedContext(Context transactionContext) throws UtilsException{
  398.         
  399.         try {
  400.         
  401.             SerializedContext sc = new SerializedContext();
  402.             JavaSerializer jSerializer = new JavaSerializer();
  403.             for (MapKey<String> key : transactionContext.keySet()) {
  404.                 Object o = transactionContext.get(key);
  405.                 if(!CostantiPdD.SALVA_CONTESTO_IDENTIFICATIVO_MESSAGGIO_NOTIFICA.equals(key) && 
  406.                         (o instanceof Serializable)
  407.                         ) {
  408.                     SerializedParameter p = new SerializedParameter();
  409.                     p.setNome(key.getValue());
  410.                     p.setClasse(o.getClass().getName());
  411.                     ByteArrayOutputStream bout = new ByteArrayOutputStream();
  412.                     jSerialize(jSerializer, o, bout, p);
  413.                     bout.flush();
  414.                     bout.close();
  415.                     p.setBase(bout.toByteArray());
  416.                     sc.addProperty(p);
  417.                 }
  418.             }
  419.             return sc;
  420.             
  421.         }catch(Exception e){
  422.             throw new UtilsException(e.getMessage(),e);
  423.         }
  424.     }
  425.     private static void jSerialize(JavaSerializer jSerializer, Object o, ByteArrayOutputStream bout, SerializedParameter p) throws UtilsException {
  426.         try {
  427.             jSerializer.writeObject(o, bout);
  428.         }catch(Exception t) {
  429.             throw new UtilsException("Serialization error (nome:"+p.getNome()+" classe:"+p.getClasse()+"): "+t.getMessage(), t);
  430.         }
  431.     }
  432. }




Created with JaCoCo 0.8.8.202204050719