HttpServletConnectorOutMessage.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.  */
  20. package org.openspcoop2.pdd.services.connector.messages;

  22. import java.io.FileInputStream;
  23. import java.io.OutputStream;
  24. import java.util.Iterator;
  25. import java.util.List;

  27. import javax.servlet.http.HttpServletResponse;

  29. import org.apache.commons.lang.StringUtils;
  30. import org.openspcoop2.core.config.PortaApplicativa;
  31. import org.openspcoop2.core.config.PortaDelegata;
  32. import org.openspcoop2.core.config.Proprieta;
  33. import org.openspcoop2.core.id.IDPortaApplicativa;
  34. import org.openspcoop2.core.id.IDPortaDelegata;
  35. import org.openspcoop2.message.OpenSPCoop2Message;
  36. import org.openspcoop2.message.OpenSPCoop2MessageProperties;
  37. import org.openspcoop2.message.OpenSPCoop2RestMessage;
  38. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  39. import org.openspcoop2.message.constants.ServiceBinding;
  40. import org.openspcoop2.message.exception.MessageException;
  41. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  42. import org.openspcoop2.pdd.config.CostantiProprieta;
  43. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  44. import org.openspcoop2.pdd.services.connector.ConnectorException;
  45. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  46. import org.openspcoop2.protocol.sdk.constants.IDService;
  47. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  48. import org.openspcoop2.utils.LoggerWrapperFactory;
  49. import org.openspcoop2.utils.Utilities;
  50. import org.openspcoop2.utils.UtilsException;
  51. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  52. import org.openspcoop2.utils.resources.Charset;
  53. import org.openspcoop2.utils.transport.http.RFC2047Encoding;
  54. import org.openspcoop2.utils.transport.http.RFC2047Utilities;

  56. /**
  57.  * HttpServletConnectorOutMessage
  58.  *
  59.  * @author Andrea Poli (apoli@link.it)
  60.  * @author $Author$
  61.  * @version $Rev$, $Date$
  62.  */
  63. public class HttpServletConnectorOutMessage implements ConnectorOutMessage {

  65.     protected HttpServletResponse res;
  66.     protected OutputStream outNullable;
  67.     protected IProtocolFactory<?> protocolFactory;
  68.     protected RequestInfo requestInfo;
  69.     protected String idModulo;
  70.     protected IDService idModuloAsIDService;
  71.     protected OpenSPCoop2Properties openspcoopProperties;
  72.     
  73.     
  74.     public HttpServletConnectorOutMessage(RequestInfo requestInfo,IProtocolFactory<?> protocolFactory, HttpServletResponse res,
  75.             IDService idModuloAsIDService, String idModulo) throws ConnectorException{
  76.         try{
  77.             this.res = res;
  78.             this.protocolFactory = protocolFactory;
  79.             this.requestInfo = requestInfo;
  80.             this.idModuloAsIDService = idModuloAsIDService;
  81.             this.idModulo = idModulo;
  82.             this.openspcoopProperties =  OpenSPCoop2Properties.getInstance();
  83.         }catch(Exception e){
  84.             throw new ConnectorException(e.getMessage(),e);
  85.         }
  86.     }

  88.     private void sendHeadersEngine(OpenSPCoop2Message msg) throws ConnectorException, MessageException {
  89.         if(msg==null) {
  90.             throw new ConnectorException("Message is null");
  91.         }
  92.         // Propago eventuali header http
  93.         OpenSPCoop2MessageProperties forwardHeader = null;
  94.         if(ServiceBinding.REST.equals(msg.getServiceBinding())) {
  95.             forwardHeader = msg.getForwardTransportHeader(this.openspcoopProperties.getRESTServicesHeadersForwardConfig(false));
  96.         }
  97.         else {
  98.             forwardHeader = msg.getForwardTransportHeader(this.openspcoopProperties.getSOAPServicesHeadersForwardConfig(false));
  99.         }
  100.         if(forwardHeader!=null && forwardHeader.size()>0){
  101.             Iterator<String> keys = forwardHeader.getKeys();
  102.             while (keys.hasNext()) {
  103.                 String key = keys.next();
  104.                 List<String> values = forwardHeader.getPropertyValues(key);
  105.                 if(values!=null && !values.isEmpty()) {
  106.                     for (String value : values) {
  107.                         this.addHeader(key, value); 
  108.                     }
  109.                 }
  110.             }
  111.         }
  112.     }
  113.     
  114.     @Override
  115.     public void sendResponse(OpenSPCoop2Message msg, boolean consume) throws ConnectorException {
  116.         try{
  117.             if(msg==null) {
  118.                 throw new ConnectorException("Message is null");
  119.             }
  120.             
  121.             // Propago eventuali header http
  122.             this.sendHeadersEngine(msg);
  123.             
  124.             boolean hasContent = false;
  125.             
  126.             // il save e' necessario con i connettori directVM in caso di errori di validazione
  127.             if(ServiceBinding.SOAP.equals(msg.getServiceBinding())){
  128.                 hasContent = true;
  129.                 OpenSPCoop2SoapMessage soap = msg.castAsSoap();
  130.                 if(soap.hasSOAPFault()){
  131.                     soap.saveChanges();
  132.                 }
  133.             }
  134.             if(ServiceBinding.REST.equals(msg.getServiceBinding())){
  135.                 OpenSPCoop2RestMessage<?> rest = msg.castAsRest();
  136.                 hasContent = rest.hasContent();
  137.             }
  138.             
  139.             if(hasContent) {
  140.                 this.outNullable = this.res.getOutputStream();
  141.                 msg.writeTo(this.outNullable,consume);
  142.             }
  143.         }catch(Exception e){
  144.             throw new ConnectorException(e.getMessage(),e);
  145.         }
  146.     }
  147.     
  148.     @Override
  149.     public void sendResponse(DumpByteArrayOutputStream message) throws ConnectorException{
  150.         try{
  151.             if(message!=null && message.size()>0) {
  152.                 this.outNullable = this.res.getOutputStream();
  153.                 if(message.isSerializedOnFileSystem()) {
  154.                     try(FileInputStream fin = new FileInputStream(message.getSerializedFile())) {
  155.                         Utilities.copy(fin, this.outNullable);
  156.                     }
  157.                 }
  158.                 else {
  159.                     this.outNullable.write(message.toByteArray());
  160.                 }
  161.             }
  162.         }catch(Exception e){
  163.             throw new ConnectorException(e.getMessage(),e);
  164.         }
  165.     }
  166.     
  167.     @Override
  168.     public void sendResponseHeaders(OpenSPCoop2Message message) throws ConnectorException{
  169.         try{
  170.             // Propago eventuali header http
  171.             this.sendHeadersEngine(message);
  172.         }catch(Exception e){
  173.             throw new ConnectorException(e.getMessage(),e);
  174.         }
  175.     }
  176.     
  177.     @Override
  178.     public void setHeader(String key,String value) throws ConnectorException{
  179.         putHeaderEngine(key,value,false);
  180.     }
  181.     @Override
  182.     public void addHeader(String key,String value) throws ConnectorException{
  183.         putHeaderEngine(key,value,true);
  184.     }
  185.     private void putHeaderEngine(String key,String value, boolean add) throws ConnectorException{
  186.         try{
  187.             if(value==null) {
  188.                 return;
  189.             }
  190.             
  191.             boolean encodingRFC2047 = false;
  192.             Charset charsetRFC2047 = null;
  193.             RFC2047Encoding encodingAlgorithmRFC2047 = null;
  194.             boolean validazioneHeaderRFC2047 = false;
  195.             List<Proprieta> listProprieta = null;
  196.             if(this.idModuloAsIDService!=null){
  197.                 switch (this.idModuloAsIDService) {
  198.                 case PORTA_DELEGATA:
  199.                 case PORTA_DELEGATA_INTEGRATION_MANAGER:
  200.                 case PORTA_DELEGATA_XML_TO_SOAP:
  201.                     encodingRFC2047 = this.openspcoopProperties.isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi();
  202.                     charsetRFC2047 = this.openspcoopProperties.getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi();
  203.                     encodingAlgorithmRFC2047 = this.openspcoopProperties.getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi();
  204.                     validazioneHeaderRFC2047 = this.openspcoopProperties.isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi();
  205.                     listProprieta = readProprietaPortaDelegata();
  206.                     break;
  207.                 case PORTA_APPLICATIVA:
  208.                     encodingRFC2047 = this.openspcoopProperties.isEnabledEncodingRFC2047HeaderValueRicezioneBuste();
  209.                     charsetRFC2047 = this.openspcoopProperties.getCharsetEncodingRFC2047HeaderValueRicezioneBuste();
  210.                     encodingAlgorithmRFC2047 = this.openspcoopProperties.getEncodingRFC2047HeaderValueRicezioneBuste();
  211.                     validazioneHeaderRFC2047 = this.openspcoopProperties.isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste();
  212.                     listProprieta = readProprietaPortaApplicativa();
  213.                     break;
  214.                 default:
  215.                     break;
  216.                 }
  217.             }
  218.             
  219.             encodingRFC2047 = CostantiProprieta.isConnettoriHeaderValueEncodingRFC2047ResponseEnabled(listProprieta, encodingRFC2047);
  220.             charsetRFC2047 = CostantiProprieta.getConnettoriHeaderValueEncodingRFC2047ResponseCharset(listProprieta, charsetRFC2047);
  221.             encodingAlgorithmRFC2047 = CostantiProprieta.getConnettoriHeaderValueEncodingRFC2047ResponseType(listProprieta, encodingAlgorithmRFC2047);
  222.             validazioneHeaderRFC2047 = CostantiProprieta.isConnettoriHeaderValidationResponseEnabled(listProprieta, validazioneHeaderRFC2047);
  223.             /**System.out.println("@@@@ encodingRFC2047["+encodingRFC2047+"] charsetRFC2047["+charsetRFC2047+"] encodingAlgorithmRFC2047["+encodingAlgorithmRFC2047+"] validazioneHeaderRFC2047["+validazioneHeaderRFC2047+"]");*/
  224.             if(encodingRFC2047){
  225.                 /**System.out.println("@@@@ CONTROLLO '"+value+" rispetto a '"+charsetRFC2047+"': "+RFC2047Utilities.isAllCharactersInCharset(value, charsetRFC2047));*/
  226.                 if(!RFC2047Utilities.isAllCharactersInCharset(value, charsetRFC2047)){
  227.                     String encoded = RFC2047Utilities.encode((value+""), charsetRFC2047, encodingAlgorithmRFC2047);
  228.                     /**System.out.println("@@@@ RESPONSE CODIFICA ["+value+"] in ["+encoded+"]");*/
  229.                     this.putResponseHeader(validazioneHeaderRFC2047, key, encoded, add);
  230.                 }
  231.                 else{
  232.                     this.putResponseHeader(validazioneHeaderRFC2047, key, value, add);
  233.                 }
  234.             }
  235.             else{
  236.                 this.putResponseHeader(validazioneHeaderRFC2047, key, value, add);
  237.             }   
  238.             
  239.         }catch(Exception e){
  240.             throw new ConnectorException(e.getMessage(),e);
  241.         }
  242.     }
  243.     
  244.     private List<Proprieta> readProprietaPortaApplicativa(){
  245.         if(this.requestInfo!=null && this.requestInfo.getProtocolContext()!=null && this.requestInfo.getProtocolContext().getInterfaceName()!=null && 
  246.                 StringUtils.isNotEmpty(this.requestInfo.getProtocolContext().getInterfaceName())) {
  247.             IDPortaApplicativa idPA = new IDPortaApplicativa();
  248.             idPA.setNome(this.requestInfo.getProtocolContext().getInterfaceName());
  249.             try {
  250.                 PortaApplicativa pa = ConfigurazionePdDManager.getInstance().getPortaApplicativaSafeMethod(idPA, this.requestInfo);
  251.                 if(pa!=null && pa.sizeProprieta()>0) {
  252.                     return pa.getProprieta();
  253.                 }
  254.             }catch(Exception e) {
  255.                 if(this.protocolFactory!=null && this.protocolFactory.getLogger()!=null) {
  256.                     this.protocolFactory.getLogger().error("Accesso porta applicativa ["+this.requestInfo.getProtocolContext().getInterfaceName()+"] fallito: "+e.getMessage(),e);
  257.                 }
  258.             }
  259.         }
  260.         return null;
  261.     }
  262.     private List<Proprieta> readProprietaPortaDelegata(){
  263.         if(this.requestInfo!=null && this.requestInfo.getProtocolContext()!=null && this.requestInfo.getProtocolContext().getInterfaceName()!=null && 
  264.                 StringUtils.isNotEmpty(this.requestInfo.getProtocolContext().getInterfaceName())) {
  265.             IDPortaDelegata idPD = new IDPortaDelegata();
  266.             idPD.setNome(this.requestInfo.getProtocolContext().getInterfaceName());
  267.             try {
  268.                 PortaDelegata pd = ConfigurazionePdDManager.getInstance().getPortaDelegataSafeMethod(idPD, this.requestInfo);
  269.                 if(pd!=null && pd.sizeProprieta()>0) {
  270.                     return pd.getProprieta();
  271.                 }
  272.             }catch(Exception e) {
  273.                 if(this.protocolFactory!=null && this.protocolFactory.getLogger()!=null) {
  274.                     this.protocolFactory.getLogger().error("Accesso porta applicativa ["+this.requestInfo.getProtocolContext().getInterfaceName()+"] fallito: "+e.getMessage(),e);
  275.                 }
  276.             }
  277.         }
  278.         return null;
  279.     }
  280.     
  281.     private void putResponseHeader(boolean validazioneHeaderRFC2047, String key, String value, boolean add) {
  282.         
  283.         if(validazioneHeaderRFC2047){
  284.             try{
  285.                 RFC2047Utilities.validHeader(key, value);
  286.                 if(add) {
  287.                     this.res.addHeader(key,value);
  288.                 }
  289.                 else {
  290.                     this.res.setHeader(key,value);
  291.                 }
  292.             }catch(UtilsException e){
  293.                 if(this.protocolFactory!=null && this.protocolFactory.getLogger()!=null){
  294.                     this.protocolFactory.getLogger().error(e.getMessage(),e);
  295.                 }
  296.                 else{
  297.                     LoggerWrapperFactory.getLogger(HttpServletConnectorOutMessage.class).error(e.getMessage(),e);       
  298.                 }
  299.             }
  300.         }
  301.         else{
  302.             if(add) {
  303.                 this.res.addHeader(key,value);
  304.             }
  305.             else {
  306.                 this.res.setHeader(key,value);
  307.             }
  308.         }
  309.         
  310.     }
  311.     
  312.     @Override
  313.     public void setContentLength(int length) throws ConnectorException{
  314.         try{
  315.             this.res.setContentLength(length);
  316.         }catch(Exception e){
  317.             throw new ConnectorException(e.getMessage(),e);
  318.         }
  319.     }
  320.     
  321.     @Override
  322.     public void setContentType(String type) throws ConnectorException{
  323.         try{
  324.             this.res.setContentType(type);
  325.         }catch(Exception e){
  326.             throw new ConnectorException(e.getMessage(),e);
  327.         }
  328.     }
  329.     
  330.     private int status = -1;
  331.     @Override
  332.     public void setStatus(int status) throws ConnectorException{
  333.         try{
  334.             this.res.setStatus(status);
  335.             this.status = status;
  336.         }catch(Exception e){
  337.             throw new ConnectorException(e.getMessage(),e);
  338.         }
  339.     }
  340.     @Override
  341.     public int getResponseStatus() throws ConnectorException{
  342.         return this.status;
  343.     }
  344.     
  345.     @Override
  346.     public void flush(boolean throwException) throws ConnectorException{
  347.         try{
  348.             // Flush and close response
  349.             // NOTA: per poter ottenere l'errore di BrokenPipe sempre, deve essere disabilitato il socketBufferOutput sul servlet container.
  350.             // Se non lo si disabilta, l'errore viene ritornato solo se il messaggio supera la dimensione del buffer (default: 8192K)
  351.             // Ad esempio in tomcat utilizzare (socketBuffer="-1"): 
  352.             //    <Connector protocol="HTTP/1.1" port="8080" address="${jboss.bind.address}" 
  353.             //       connectionTimeout="20000" redirectPort="8443" socketBuffer="-1" />
  354.             if(this.res!=null){
  355.                 try{
  356.                     this.res.flushBuffer();
  357.                 }catch(Exception e){
  358.                     if(throwException){
  359.                         throw e;
  360.                     }
  361.                 }
  362.             }
  363.             if(this.outNullable!=null){
  364.                 try{
  365.                     this.outNullable.flush();
  366.                 }catch(Exception e){
  367.                     if(throwException){
  368.                         throw e;
  369.                     }
  370.                 }
  371.             }
  372.         }catch(Exception e){
  373.             throw new ConnectorException(e.getMessage(),e);
  374.         }   
  375.     }
  376.     
  377.     @Override
  378.     public void close(boolean throwException) throws ConnectorException{
  379.         try{
  380.             if(this.outNullable!=null){
  381.                 try{
  382.                     this.outNullable.close();
  383.                     this.outNullable = null;
  384.                 }catch(Exception e){
  385.                     if(throwException){
  386.                         throw e;
  387.                     }
  388.                 }
  389.             }
  390.         }catch(Exception e){
  391.             throw new ConnectorException(e.getMessage(),e);
  392.         }   
  393.     }
  394. }
Created with JaCoCo 0.8.8.202204050719