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

  21. package org.openspcoop2.pdd.services.connector.messages;

  23. import java.io.ByteArrayOutputStream;
  24. import java.io.File;
  25. import java.io.PrintWriter;
  26. import java.util.HashMap;
  27. import java.util.Iterator;
  28. import java.util.List;
  29. import java.util.Map;

  31. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  32. import org.openspcoop2.message.OpenSPCoop2Message;
  33. import org.openspcoop2.message.OpenSPCoop2MessageProperties;
  34. import org.openspcoop2.message.OpenSPCoop2RestMessage;
  35. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  36. import org.openspcoop2.message.constants.MessageRole;
  37. import org.openspcoop2.message.constants.MessageType;
  38. import org.openspcoop2.message.constants.ServiceBinding;
  39. import org.openspcoop2.message.exception.ParseException;
  40. import org.openspcoop2.message.exception.ParseExceptionUtils;
  41. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  42. import org.openspcoop2.pdd.services.DumpRaw;
  43. import org.openspcoop2.pdd.services.connector.ConnectorException;
  44. import org.openspcoop2.protocol.sdk.Context;
  45. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  46. import org.openspcoop2.utils.transport.TransportUtils;
  47. import org.slf4j.Logger;

  49. /**
  50.  * DumpRawConnectorOutMessage
  51.  * 
  52.  * @author Poli Andrea (apoli@link.it)
  53.  * @author $Author$
  54.  * @version $Rev$, $Date$
  55.  */
  56. public class DumpRawConnectorOutMessage implements ConnectorOutMessage {

  58.     private Logger log;
  59.     private ConnectorOutMessage connectorOutMessage;
  60.     private DumpByteArrayOutputStream bout = null;
  61.     private MessageType messageType = null;
  62.     private ParseException parseException = null;
  63.     private Map<String, List<String>> trasporto = new HashMap<>();
  64.     private Integer contentLenght;
  65.     private String contentType;
  66.     private Integer status;
  67.     private OpenSPCoop2Properties openspcoopProperties;
  68.     
  69.     private Context context;
  70.     private String idTransazione;
  71.     private int soglia;
  72.     private File repositoryFile;
  73.     
  74.     private DumpRaw dumpRaw;
  75.     
  76.     public DumpRawConnectorOutMessage(Logger log,ConnectorOutMessage connectorOutMessage, Context context,
  77.             int soglia, File repositoryFile,
  78.             DumpRaw dump){
  79.         this.log = log;
  80.         this.connectorOutMessage = connectorOutMessage;
  81.         this.openspcoopProperties =  OpenSPCoop2Properties.getInstance();
  82.         
  83.         this.context = context;
  84.         if(this.context!=null) {
  85.             this.idTransazione = (String) this.context.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  86.         }
  87.         this.soglia = soglia;
  88.         this.repositoryFile = repositoryFile;
  89.         
  90.         this.dumpRaw = dump;
  91.     }
  92.     
  93.     public ConnectorOutMessage getWrappedConnectorOutMessage() {
  94.         return this.connectorOutMessage;
  95.     }
  96.     
  97.     public DumpByteArrayOutputStream getDumpByteArrayOutputStream() {
  98.         if(this.bout!=null && this.bout.size()>0){
  99.             return this.bout;
  100.         }
  101.         return null;
  102.     }
  103. //  public byte[] getResponseAsByte(){
  104. //      if(this.bout!=null && this.bout.size()>0){
  105. //          return this.bout.toByteArray();
  106. //      }
  107. //      return null;
  108. //  }
  109. //  public String getResponseAsString(){
  110. //      if(this.bout!=null && this.bout.size()>0){
  111. //          return this.bout.toString();
  112. //      }
  113. //      return null;
  114. //  }
  115.     public MessageType getMessageType() {
  116.         return this.messageType;
  117.     }
  118.     public boolean isParsingResponseError(){
  119.         return this.parseException!=null;
  120.     }
  121.     public String getParsingResponseErrorAsString(){
  122.         if(this.parseException!=null){
  123.             try{
  124.                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  125.                 PrintWriter pw = new PrintWriter(bout);
  126.                 this.parseException.getSourceException().printStackTrace(pw);
  127.                 pw.flush();
  128.                 bout.flush();
  129.                 pw.close();
  130.                 bout.close();
  131.                 return bout.toString();
  132.             }catch(Exception e){
  133.                 return "ParsingResponseError, serializazione eccezione non riuscita: "+e.getMessage();
  134.             }
  135.         }
  136.         return null;
  137.     }
  138.     
  139.     public Map<String, List<String>> getTrasporto() {
  140.         return this.trasporto;
  141.     }

  143.     public Integer getContentLenght() {
  144.         return this.contentLenght;
  145.     }

  147.     public String getContentType() {
  148.         return this.contentType;
  149.     }
  150.     public Integer getStatus() {
  151.         return this.status;
  152.     }
  153.     
  154.     private boolean emitDiagnostic = false;
  155.     private void emitDiagnosticStartDumpBinarioRispostaUscita() {
  156.         if(this.dumpRaw!=null && !this.emitDiagnostic) {
  157.             this.emitDiagnostic = true;
  158.             this.dumpRaw.emitDiagnosticStartDumpBinarioRispostaUscita();
  159.         }
  160.     }
  161.     
  162.     private void _sendHeaders(OpenSPCoop2Message message) throws Exception {
  163.         if(message==null) {
  164.             throw new Exception("Message is null");
  165.         }
  166.         // Eventuali header http propagati
  167.         OpenSPCoop2MessageProperties forwardHeader = null;
  168.         if(ServiceBinding.REST.equals(message.getServiceBinding())) {
  169.             forwardHeader = message.getForwardTransportHeader(this.openspcoopProperties.getRESTServicesHeadersForwardConfig(false));
  170.         }
  171.         else {
  172.             forwardHeader = message.getForwardTransportHeader(this.openspcoopProperties.getSOAPServicesHeadersForwardConfig(false));
  173.         }
  174.         if(forwardHeader!=null && forwardHeader.size()>0){
  175.             Iterator<String> keys = forwardHeader.getKeys();
  176.             while (keys.hasNext()) {
  177.                 String key = (String) keys.next();
  178.                 List<String> values = forwardHeader.getPropertyValues(key);
  179.                 if(values!=null && !values.isEmpty()) {
  180.                     for (String value : values) {
  181.                         this.addHeader(key, value);         
  182.                     }
  183.                 }
  184.             }
  185.         }
  186.     }
  187.     
  188.     @Override
  189.     public void sendResponse(OpenSPCoop2Message message, boolean consume)
  190.             throws ConnectorException {
  191.         
  192.         emitDiagnosticStartDumpBinarioRispostaUscita();
  193.         
  194.         try{
  195.             // Propago eventuali header http
  196.             this._sendHeaders(message);
  197.             
  198.             // Prima lo registro e dopo serializzo
  199.             if(this.bout!=null){
  200.                 this.bout.clearResources();
  201.                 this.bout = null;
  202.             }
  203.             this.bout = new DumpByteArrayOutputStream(this.soglia, this.repositoryFile, this.idTransazione, 
  204.                     TipoMessaggio.RISPOSTA_USCITA_DUMP_BINARIO.getValue());
  205.             
  206.             boolean hasContent = false;
  207.             
  208.             // il save e' necessario con i connettori in caso di errori di validazione
  209.             if(message!=null && ServiceBinding.SOAP.equals(message.getServiceBinding())){
  210.                 hasContent = true;
  211.                 OpenSPCoop2SoapMessage soap = message.castAsSoap();
  212.                 if(soap.hasSOAPFault()){
  213.                     soap.saveChanges();
  214.                 }
  215.             } 
  216.             if(message!=null && ServiceBinding.REST.equals(message.getServiceBinding())){
  217.                 OpenSPCoop2RestMessage<?> rest = message.castAsRest();
  218.                 hasContent = rest.hasContent();
  219.             }
  220.             
  221.             if(hasContent) {
  222.                 message.writeTo(this.bout, consume);
  223.             }
  224.             
  225.             if(message!=null) {
  226.                 this.messageType = message.getMessageType();
  227.             }
  228.             
  229.         }catch(Throwable t){
  230.             this.bout = null;
  231.             if(message.getParseException()!=null){
  232.                 this.parseException = message.getParseException();
  233.             }
  234.             else{
  235.                 this.parseException = ParseExceptionUtils.buildParseException(t,MessageRole.RESPONSE);
  236.             }
  237.             this.log.error("SendResponse error: "+t.getMessage(),t);
  238.             // Devo lanciare l'eccezione senno il servizio esce con 200
  239.             throw new ConnectorException(this.parseException.getSourceException());
  240.         }finally{
  241.             try{
  242.                 if(this.bout!=null){
  243.                     this.bout.flush();
  244.                 }
  245.             }catch(Throwable close){}
  246.             try{
  247.                 if(this.bout!=null){
  248.                     this.bout.close();
  249.                 }
  250.             }catch(Throwable close){}
  251.         }
  252.         
  253.         // wrapped method
  254.         //this.connectorOutMessage.sendResponse(message, consume); Nel caso di attachments genera un nuovo boundary
  255.         if(this.bout!=null){
  256.             this.connectorOutMessage.sendResponse(this.bout);
  257.         }
  258.     }

  260.     @Override
  261.     public void sendResponse(DumpByteArrayOutputStream message) throws ConnectorException {
  262.     
  263.         emitDiagnosticStartDumpBinarioRispostaUscita();
  264.         
  265.         try{
  266.             // Prima lo registro e dopo serializzo
  267.             if(this.bout!=null){
  268.                 this.bout.clearResources();
  269.                 this.bout = null;
  270.             }
  271.             if(message!=null && message.size()>0) {
  272.                 this.bout = message;
  273.             }
  274.         }catch(Throwable t){
  275.             try{
  276.                 this.bout = DumpByteArrayOutputStream.newInstance(("SendResponse byte[] error: "+t.getMessage()).getBytes());
  277.             }catch(Throwable tWrite){}
  278.             this.log.error("SendResponse byte[] error: "+t.getMessage(),t);
  279.         }finally{
  280.             try{
  281.                 if(this.bout!=null){
  282.                     this.bout.flush();
  283.                 }
  284.             }catch(Throwable close){}
  285.             try{
  286.                 if(this.bout!=null){
  287.                     this.bout.close();
  288.                 }
  289.             }catch(Throwable close){}
  290.         }
  291.         
  292.         // wrapped method
  293.         this.connectorOutMessage.sendResponse(message);
  294.     }
  295.     
  296.     @Override
  297.     public void sendResponseHeaders(OpenSPCoop2Message message) throws ConnectorException{
  298.         
  299.         emitDiagnosticStartDumpBinarioRispostaUscita();
  300.         
  301.         try{
  302.             // Propago eventuali header http
  303.             this._sendHeaders(message);
  304.         }catch(Exception e){
  305.             throw new ConnectorException(e.getMessage(),e);
  306.         }
  307.     }

  309.     @Override
  310.     public void setHeader(String key, String value) throws ConnectorException {
  311.         try{
  312.             // Prima lo registro e dopo serializzo
  313.             TransportUtils.setHeader(this.trasporto, key, value);
  314.         }catch(Throwable t){
  315.             try{
  316.                 this.bout = DumpByteArrayOutputStream.newInstance(("setHeader ["+key+"] error: "+t.getMessage()).getBytes());
  317.             }catch(Throwable tWrite){}
  318.             this.log.error("Set Header ["+key+"]["+value+"] error: "+t.getMessage(),t);
  319.         }
  320.         
  321.         // wrapped method
  322.         this.connectorOutMessage.setHeader(key,value);
  323.     }
  324.     @Override
  325.     public void addHeader(String key, String value) throws ConnectorException {
  326.         try{
  327.             // Prima lo registro e dopo serializzo
  328.             TransportUtils.addHeader(this.trasporto, key, value);
  329.         }catch(Throwable t){
  330.             try{
  331.                 this.bout = DumpByteArrayOutputStream.newInstance(("addHeader ["+key+"] error: "+t.getMessage()).getBytes());
  332.             }catch(Throwable tWrite){}
  333.             this.log.error("Add Header ["+key+"]["+value+"] error: "+t.getMessage(),t);
  334.         }
  335.         
  336.         // wrapped method
  337.         this.connectorOutMessage.addHeader(key,value);
  338.     }

  340.     @Override
  341.     public void setContentLength(int length) throws ConnectorException {
  342.         
  343.         // Prima lo registro
  344.         this.contentLenght = length;
  345.         
  346.         // wrapped method
  347.         this.connectorOutMessage.setContentLength(length);
  348.     }

  350.     @Override
  351.     public void setContentType(String type) throws ConnectorException {
  352.         
  353.         // Prima lo registro
  354.         this.contentType = type;
  355.         
  356.         // wrapped method
  357.         this.connectorOutMessage.setContentType(type);
  358.     }

  360.     @Override
  361.     public void setStatus(int status) throws ConnectorException {
  362.     
  363.         // Prima lo registro
  364.         this.status = status;
  365.         
  366.         // wrapped method
  367.         this.connectorOutMessage.setStatus(status);
  368.     }

  370.     
  371.     // Wrapped Only
  372.     
  373.     @Override
  374.     public int getResponseStatus() throws ConnectorException {
  375.         // wrapped method
  376.         return this.connectorOutMessage.getResponseStatus();
  377.     }

  379.     @Override
  380.     public void flush(boolean throwException) throws ConnectorException {
  381.         // wrapped method
  382.         this.connectorOutMessage.flush(throwException);
  383.     }

  385.     @Override
  386.     public void close(boolean throwException) throws ConnectorException {
  387.         // wrapped method
  388.         this.connectorOutMessage.close(throwException);
  389.     }

  391. }
Created with JaCoCo 0.8.8.202204050719