ConnectorDispatcherUtils.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;

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

  31. import javax.servlet.http.HttpServletRequest;
  32. import javax.servlet.http.HttpServletResponse;

  34. import org.openspcoop2.message.OpenSPCoop2Message;
  35. import org.openspcoop2.message.constants.ServiceBinding;
  36. import org.openspcoop2.message.exception.ParseException;
  37. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  38. import org.openspcoop2.pdd.core.CostantiPdD;
  39. import org.openspcoop2.pdd.core.integrazione.HeaderIntegrazione;
  40. import org.openspcoop2.pdd.core.integrazione.UtilitiesIntegrazione;
  41. import org.openspcoop2.pdd.services.connector.messages.ConnectorOutMessage;
  42. import org.openspcoop2.pdd.services.error.RicezioneBusteExternalErrorGenerator;
  43. import org.openspcoop2.pdd.services.error.RicezioneContenutiApplicativiInternalErrorGenerator;
  44. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  45. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  46. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  47. import org.openspcoop2.protocol.sdk.constants.IDService;
  48. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  49. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  50. import org.openspcoop2.utils.CopyStream;
  51. import org.openspcoop2.utils.transport.TransportUtils;
  52. import org.openspcoop2.utils.transport.http.HttpConstants;
  53. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  54. import org.slf4j.Logger;
  55. import org.w3c.dom.Document;

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

  66.     public static final boolean CLIENT_ERROR = true;
  67.     public static final boolean GENERAL_ERROR = false;
  68.     
  69.     public static void doServiceBindingNotSupported(HttpServletRequest req, HttpServletResponse res, HttpRequestMethod httpMethod, ServiceBinding serviceBinding, IDService idService) throws IOException{
  70.         
  71.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  72.         
  73.         // messaggio di errore
  74.         boolean errore404 = false;
  75.         if(op2Properties!=null){
  76.             if(IDService.PORTA_DELEGATA.equals(idService)){
  77.                 if(op2Properties.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled()==false){
  78.                     errore404 = true;
  79.                 }
  80.             }
  81.             else if(IDService.PORTA_DELEGATA_XML_TO_SOAP.equals(idService)){
  82.                 if(op2Properties.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled()==false){
  83.                     errore404 = true;
  84.                 }
  85.             }
  86.             else if(IDService.PORTA_APPLICATIVA.equals(idService)){
  87.                 if(op2Properties.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled()==false){
  88.                     errore404 = true;
  89.                 }
  90.             }
  91.             else{
  92.                 throw new IOException("Service ["+idService+"] not supported");
  93.             }
  94.         }
  95.         
  96.         if(errore404){
  97.             res.sendError(404,ConnectorUtils.generateError404Message(ConnectorUtils.getFullCodeServiceBindingNotSupported(idService, serviceBinding)));
  98.         }
  99.         else{
  100.         
  101.             res.setStatus(500);
  102.             
  103.             ConnectorUtils.generateErrorMessage(idService,httpMethod,req,res, ConnectorUtils.getMessageServiceBindingNotSupported(serviceBinding), false, true);
  104.             
  105.             try{
  106.                 res.getOutputStream().flush();
  107.             }catch(Exception eClose){
  108.                 // ignore
  109.             }
  110.             try{
  111.                 res.getOutputStream().close();
  112.             }catch(Exception eClose){
  113.                 // ignore
  114.             }
  115.             
  116.         }
  117.     }
  118.     
  119.     public static void doMethodNotSupported(HttpServletRequest req, HttpServletResponse res, HttpRequestMethod method, IDService idService) throws IOException{
  120.         
  121.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  122.         
  123.         // messaggio di errore
  124.         boolean errore404 = false;
  125.         if(op2Properties!=null){
  126.             if(IDService.PORTA_DELEGATA.equals(idService)){
  127.                 if(op2Properties.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled()==false){
  128.                     errore404 = true;
  129.                 }
  130.             }
  131.             else if(IDService.PORTA_DELEGATA_XML_TO_SOAP.equals(idService)){
  132.                 if(op2Properties.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled()==false){
  133.                     errore404 = true;
  134.                 }
  135.             }
  136.             else if(IDService.PORTA_APPLICATIVA.equals(idService)){
  137.                 if(op2Properties.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled()==false){
  138.                     errore404 = true;
  139.                 }
  140.             }
  141.             else{
  142.                 throw new IOException("Service ["+idService+"] not supported");
  143.             }
  144.         }
  145.         
  146.         if(errore404){
  147.             res.sendError(404,ConnectorUtils.generateError404Message(ConnectorUtils.getFullCodeHttpMethodNotSupported(idService, method)));
  148.         }
  149.         else{
  150.         
  151.             res.setStatus(500);
  152.             
  153.             ConnectorUtils.generateErrorMessage(idService,method,req,res, ConnectorUtils.getMessageHttpMethodNotSupported(method), false, true);
  154.             
  155.             try{
  156.                 res.getOutputStream().flush();
  157.             }catch(Exception eClose){
  158.                 // ignore
  159.             }
  160.             try{
  161.                 res.getOutputStream().close();
  162.             }catch(Exception eClose){
  163.                 // ignore
  164.             }
  165.             
  166.         }
  167.     }
  168.     
  169.     
  170.     public static void doWsdl(HttpServletRequest req, HttpServletResponse res, HttpRequestMethod method, IDService idService ) throws IOException{
  171.         
  172.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  173.         String versione = CostantiPdD.OPENSPCOOP2_PRODUCT_VERSION;
  174.         if(op2Properties!=null){
  175.             versione = op2Properties.getPddDetailsForServices();
  176.         }
  177.         
  178.         
  179.         InputStream is =null;
  180.         try{
  181.             
  182.             String wsdl = null;
  183.             boolean generazioneWsdlEnabled = false;
  184.             if(IDService.PORTA_DELEGATA.equals(idService)){
  185.                 wsdl = "/PD.wsdl";
  186.                 if(op2Properties!=null){
  187.                     generazioneWsdlEnabled = op2Properties.isGenerazioneWsdlPortaDelegataEnabled();
  188.                 }
  189.             }
  190.             else if(IDService.PORTA_APPLICATIVA.equals(idService)){
  191.                 wsdl = "/PA.wsdl";
  192.                 if(op2Properties!=null){
  193.                     generazioneWsdlEnabled = op2Properties.isGenerazioneWsdlPortaApplicativaEnabled();
  194.                 }
  195.             }
  196.             else{
  197.                 throw new Exception("Service ["+idService+"] not supported");
  198.             }
  199.             
  200.             is = RicezioneContenutiApplicativiConnector.class.getResourceAsStream(wsdl);
  201.             ByteArrayOutputStream bout = new ByteArrayOutputStream();

  203.             if(is!=null){
  204. //              int letti = 0;
  205. //              byte [] buffer = new byte[Utilities.DIMENSIONE_BUFFER];
  206. //              while( (letti=is.read(buffer)) != -1 ){
  207. //                  bout.write(buffer, 0, letti);
  208. //              }
  209.                 CopyStream.copy(is, bout);
  210.                 bout.flush();
  211.                 bout.close();
  212.             }
  213.             
  214.             if(generazioneWsdlEnabled){
  215.             
  216.                 if(bout.size()<=0){
  217.                     throw new Exception("WSDL Not Found");
  218.                 }
  219.                 
  220.                 byte[] b = bout.toByteArray();
  221.                 org.openspcoop2.message.xml.MessageXMLUtils xmlUtils = org.openspcoop2.message.xml.MessageXMLUtils.DEFAULT;
  222.                 Document d = xmlUtils.newDocument(b);
  223.                 d.getFirstChild().appendChild(d.createComment(versione));
  224.                 xmlUtils.writeTo(d, res.getOutputStream());
  225.                 
  226.             }
  227.             else{
  228.                 
  229.                 res.sendError(404, ConnectorUtils.generateError404Message(ConnectorUtils.getFullCodeWsdlUnsupported(idService)));
  230.                 
  231.             }
  232.             
  233.         }catch(Exception e){                    
  234.             res.setStatus(500);
  235.             
  236.             ConnectorUtils.generateErrorMessage(idService,method,req,res, "Generazione WSDL non riuscita", false, true);
  237.             
  238.             ConnectorUtils.getErrorLog().error("Generazione WSDL "+idService+" non riuscita",e);    
  239.         }finally{
  240.             try{
  241.                 res.getOutputStream().flush();
  242.             }catch(Exception eClose){
  243.                 // ignore
  244.             }
  245.             try{
  246.                 res.getOutputStream().close();
  247.             }catch(Exception eClose){
  248.                 // ignore
  249.             }
  250.             try{
  251.                 if(is!=null)
  252.                     is.close();
  253.             }catch(Exception eClose){
  254.                 // ignore
  255.             }
  256.         }
  257.         return;
  258.     }
  259.     
  260.     public static void doError(RequestInfo requestInfo,
  261.             RicezioneContenutiApplicativiInternalErrorGenerator generatoreErrore, ErroreIntegrazione erroreIntegrazione,
  262.             IntegrationFunctionError integrationFunctionError, Throwable e, HttpServletResponse res, Logger log){
  263.         
  264.         IProtocolFactory<?> protocolFactory = requestInfo.getProtocolFactory();
  265.                 
  266.         if(generatoreErrore!=null){
  267.             OpenSPCoop2Message msgErrore = generatoreErrore.build(null, integrationFunctionError, erroreIntegrazione, e, null);
  268.             if(msgErrore.getForcedResponseCode()!=null){
  269.                 res.setStatus(Integer.parseInt(msgErrore.getForcedResponseCode()));
  270.             }
  271.             try{
  272.                 msgErrore.writeTo(res.getOutputStream(), true);
  273.             }catch(Exception eWriteTo){
  274.                 log.error("Errore durante la serializzazione dell'errore: "+e.getMessage(),e);
  275.                 try{
  276.                     res.sendError(500);
  277.                 }catch(Exception eInternal){
  278.                     throw new RuntimeException(eInternal.getMessage(),eInternal);
  279.                 }
  280.             }
  281.         }
  282.         else{
  283.             try{
  284.                 res.sendError(500,erroreIntegrazione.getDescrizione(protocolFactory));
  285.             }catch(Exception eInternal){
  286.                 throw new RuntimeException(eInternal.getMessage(),eInternal);
  287.             }
  288.         }
  289.         
  290.     }
  291.     
  292.     public static ConnectorDispatcherErrorInfo doError(RequestInfo requestInfo,
  293.             RicezioneContenutiApplicativiInternalErrorGenerator generatoreErrore, ErroreIntegrazione erroreIntegrazione,
  294.             IntegrationFunctionError integrationFunctionError, Throwable e, ParseException parseException,
  295.             ConnectorOutMessage res, Logger log, boolean clientError) throws ConnectorException{
  296.         
  297.         IProtocolFactory<?> protocolFactory = requestInfo.getProtocolFactory();
  298.         
  299.         if(generatoreErrore!=null){
  300.             
  301.             OpenSPCoop2Message msgErrore = generatoreErrore.build(null, integrationFunctionError, erroreIntegrazione, e, parseException);
  302.             
  303.             return _doError(requestInfo, res, log, true, erroreIntegrazione, integrationFunctionError, e, parseException, msgErrore, clientError);
  304.             
  305.         }
  306.         else{
  307.             try{
  308.                 String errore = erroreIntegrazione.getDescrizione(protocolFactory);
  309.                 throw new ConnectorException(errore);
  310.             }catch(Throwable eInternal){
  311.                 throw new ConnectorException(eInternal.getMessage(),eInternal);
  312.             }
  313.         }
  314.         
  315.     }
  316.     
  317.     public static void doError(RequestInfo requestInfo,
  318.             RicezioneBusteExternalErrorGenerator generatoreErrore, ErroreIntegrazione erroreIntegrazione,
  319.             IntegrationFunctionError integrationFunctionError, Throwable e, HttpServletResponse res, Logger log){
  320.         
  321.         IProtocolFactory<?> protocolFactory = requestInfo.getProtocolFactory();
  322.                 
  323.         if(generatoreErrore!=null){
  324.             OpenSPCoop2Message msgErrore = generatoreErrore.buildErroreProcessamento(null, integrationFunctionError, erroreIntegrazione, e);
  325.             if(msgErrore.getForcedResponseCode()!=null){
  326.                 res.setStatus(Integer.parseInt(msgErrore.getForcedResponseCode()));
  327.             }
  328.             try{
  329.                 msgErrore.writeTo(res.getOutputStream(), true);
  330.             }catch(Exception eWriteTo){
  331.                 log.error("Errore durante la serializzazione dell'errore: "+e.getMessage(),e);
  332.                 try{
  333.                     res.sendError(500);
  334.                 }catch(Exception eInternal){
  335.                     throw new RuntimeException(eInternal.getMessage(),eInternal);
  336.                 }
  337.             }
  338.         }
  339.         else{
  340.             try{
  341.                 res.sendError(500,erroreIntegrazione.getDescrizione(protocolFactory));
  342.             }catch(Exception eInternal){
  343.                 throw new RuntimeException(eInternal.getMessage(),eInternal);
  344.             }
  345.         }
  346.         
  347.     }
  348.     
  349.     public static ConnectorDispatcherErrorInfo doError(RequestInfo requestInfo,
  350.             RicezioneBusteExternalErrorGenerator generatoreErrore, ErroreIntegrazione erroreIntegrazione,
  351.             IntegrationFunctionError integrationFunctionError, Throwable e, ParseException parseException,
  352.             ConnectorOutMessage res, Logger log, boolean clientError) throws ConnectorException{
  353.         
  354.         IProtocolFactory<?> protocolFactory = requestInfo.getProtocolFactory();
  355.                 
  356.         if(generatoreErrore!=null){
  357.         
  358.             OpenSPCoop2Message msgErrore = generatoreErrore.buildErroreProcessamento(null, integrationFunctionError, erroreIntegrazione, e);
  359.             
  360.             return _doError(requestInfo, res, log, false, erroreIntegrazione, integrationFunctionError, e, parseException, msgErrore, clientError);
  361.             
  362.         }
  363.         else{
  364.             try{
  365.                 String errore = erroreIntegrazione.getDescrizione(protocolFactory);
  366.                 throw new ConnectorException(errore);
  367.             }catch(Throwable eInternal){
  368.                 throw new ConnectorException(eInternal.getMessage(),eInternal);
  369.             }
  370.         }
  371.         
  372.     }
  373.     
  374.     
  375.     
  376.     private static ConnectorDispatcherErrorInfo _doError(RequestInfo requestInfo,ConnectorOutMessage res,Logger log,boolean portaDelegata,
  377.             ErroreIntegrazione erroreIntegrazione,
  378.             IntegrationFunctionError integrationFunctionError, Throwable e, ParseException parseException,
  379.             OpenSPCoop2Message msg, boolean clientError) throws ConnectorException{
  380.         
  381.         if(requestInfo==null) {
  382.             throw new ConnectorException("RequestInfo param is null");
  383.         }
  384.         
  385.         IProtocolFactory<?> protocolFactory = requestInfo.getProtocolFactory();
  386.         
  387.         Map<String, List<String>> trasporto = new HashMap<>();
  388.         try {
  389.             UtilitiesIntegrazione utilitiesIntegrazione = null;
  390.             if(portaDelegata) {
  391.                 utilitiesIntegrazione = UtilitiesIntegrazione.getInstancePDResponse(log);
  392.             }
  393.             else {
  394.                 utilitiesIntegrazione = UtilitiesIntegrazione.getInstancePAResponse(log);
  395.             }
  396.             if(requestInfo!=null && requestInfo.getIdTransazione()!=null) {
  397.                 HeaderIntegrazione hdr = new HeaderIntegrazione(requestInfo.getIdTransazione());
  398.                 utilitiesIntegrazione.setTransportProperties(hdr,trasporto,null);
  399.             }
  400.             else {
  401.                 utilitiesIntegrazione.setInfoProductTransportProperties(trasporto);
  402.             }
  403.             utilitiesIntegrazione.setSecurityHeaders(msg!=null ? msg.getServiceBinding() : ServiceBinding.REST, requestInfo, trasporto, null);
  404.             if(trasporto.size()>0){
  405.                 Iterator<String> keys = trasporto.keySet().iterator();
  406.                 while (keys.hasNext()) {
  407.                     String key = (String) keys.next();
  408.                     List<String> values = trasporto.get(key);
  409.                     if(values!=null && !values.isEmpty()) {
  410.                         for (String value : values) {
  411.                             res.addHeader(key,value);
  412.                         }
  413.                     }
  414.                 }   
  415.             }
  416.             
  417.         }catch(Throwable error){
  418.             log.error("Errore durante la serializzazione degli headers: "+error.getMessage(),error);
  419.             try{
  420.                 throw new ConnectorException(erroreIntegrazione.getDescrizione(protocolFactory),e);
  421.             }catch(Throwable eInternal){
  422.                 // rilancio eccezione originale
  423.                 throw new ConnectorException(e.getMessage(),e);
  424.             }
  425.         }
  426.         
  427.         int status = 200;
  428.         String contentTypeRisposta = null;
  429.         if(msg!=null && msg.getForcedResponseCode()!=null){
  430.             status = Integer.parseInt(msg.getForcedResponseCode());
  431.             res.setStatus(status);
  432.         }
  433.         
  434.         // content type
  435.         // Alcune implementazioni richiedono di aggiornare il Content-Type
  436.         try{
  437.             if(msg!=null) {
  438.                 msg.updateContentType();
  439.                 contentTypeRisposta = msg.getContentType();
  440.                 if (contentTypeRisposta != null) {
  441.                     res.setContentType(contentTypeRisposta);
  442.                     TransportUtils.setHeader(trasporto,HttpConstants.CONTENT_TYPE, contentTypeRisposta);
  443.                 }
  444.             }
  445.         }catch(Throwable error){
  446.             log.error("Errore durante la serializzazione del contentType: "+error.getMessage(),error);
  447.             try{
  448.                 throw new ConnectorException(erroreIntegrazione.getDescrizione(protocolFactory),e);
  449.             }catch(Throwable eInternal){
  450.                 // rilancio eccezione originale
  451.                 throw new ConnectorException(e.getMessage(),e);
  452.             }
  453.         }
  454.         
  455.         ConnectorDispatcherErrorInfo errorInfo = null;
  456.         try{
  457.             if(clientError) {
  458.                 errorInfo = ConnectorDispatcherErrorInfo.getClientError(msg, status, contentTypeRisposta, trasporto, requestInfo, protocolFactory);
  459.             }else{
  460.                 errorInfo = ConnectorDispatcherErrorInfo.getGenericError(msg, status, contentTypeRisposta, trasporto, requestInfo, protocolFactory);    
  461.             }
  462.         }catch(Throwable error){
  463.             log.error("Errore durante la generazione delle informazioni di errore: "+error.getMessage(),error);
  464.             try{
  465.                 throw new ConnectorException(erroreIntegrazione.getDescrizione(protocolFactory),e);
  466.             }catch(Throwable eInternal){
  467.                 // rilancio eccezione originale
  468.                 throw new ConnectorException(e.getMessage(),e);
  469.             }
  470.         }

  472.         boolean consume = false; // può essere usato nel post out response handler
  473.         try{
  474.             res.sendResponse(msg, consume);
  475.         }catch(Throwable error){
  476.             log.error("Errore durante la serializzazione dell'errore: "+error.getMessage(),error);
  477.             try{
  478.                 throw new ConnectorException(erroreIntegrazione.getDescrizione(protocolFactory),e);
  479.             }catch(Throwable eInternal){
  480.                 // rilancio eccezione originale
  481.                 throw new ConnectorException(e.getMessage(),e);
  482.             }
  483.         }finally {
  484.             res.flush(false);
  485.             res.close(false);
  486.         }
  487.         
  488.         return errorInfo;
  489.     }
  490.     
  491.     
  492.     public static void doInfo(ConnectorDispatcherInfo info, RequestInfo requestInfo,ConnectorOutMessage res, Logger log, boolean portaDelegata) throws ConnectorException{
  493.         
  494.         if(requestInfo==null) {
  495.             throw new ConnectorException("RequestInfo param is null");
  496.         }
  497.         
  498.         IProtocolFactory<?> protocolFactory = requestInfo.getProtocolFactory();
  499.         
  500.         OpenSPCoop2Message msg = info.getMessage();
  501.         
  502.         Map<String, List<String>> trasporto = info.getTrasporto();
  503.         try {
  504.             UtilitiesIntegrazione utilitiesIntegrazione = null;
  505.             if(portaDelegata) {
  506.                 utilitiesIntegrazione = UtilitiesIntegrazione.getInstancePDResponse(log);
  507.             }
  508.             else {
  509.                 utilitiesIntegrazione = UtilitiesIntegrazione.getInstancePAResponse(log);
  510.             }
  511.             if(requestInfo!=null && requestInfo.getIdTransazione()!=null) {
  512.                 HeaderIntegrazione hdr = new HeaderIntegrazione(requestInfo.getIdTransazione());
  513.                 utilitiesIntegrazione.setTransportProperties(hdr,trasporto,null);
  514.             }
  515.             else {
  516.                 utilitiesIntegrazione.setInfoProductTransportProperties(trasporto);
  517.             }
  518.             utilitiesIntegrazione.setSecurityHeaders(msg!=null ? msg.getServiceBinding() : ServiceBinding.REST, requestInfo, trasporto, null);
  519.             if(trasporto.size()>0){
  520.                 Iterator<String> keys = trasporto.keySet().iterator();
  521.                 while (keys.hasNext()) {
  522.                     String key = (String) keys.next();
  523.                     List<String> values = trasporto.get(key);
  524.                     if(values!=null && !values.isEmpty()) {
  525.                         for (String value : values) {
  526.                             res.addHeader(key,value);
  527.                         }
  528.                     }
  529.                 }   
  530.             }
  531.             
  532.         }catch(Throwable error){
  533.             log.error("Errore durante la serializzazione degli headers: "+error.getMessage(),error);
  534.             try{
  535.                 throw new ConnectorException(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(error.getMessage())
  536.                         .getDescrizione(protocolFactory),error);
  537.             }catch(Throwable eInternal){
  538.                 // rilancio eccezione originale
  539.                 throw new ConnectorException(error.getMessage(),error);
  540.             }
  541.         }
  542.         
  543.         int status = 200;
  544.         String contentTypeRisposta = null;
  545.         if(msg!=null && msg.getForcedResponseCode()!=null){
  546.             status = Integer.parseInt(msg.getForcedResponseCode());
  547.             res.setStatus(status);
  548.         }
  549.         else if(info.getStatus()>0) {
  550.             status = info.getStatus();
  551.             res.setStatus(status);
  552.         }
  553.         
  554.         // content type
  555.         // Alcune implementazioni richiedono di aggiornare il Content-Type
  556.         try{
  557.             if(msg!=null) {
  558.                 msg.updateContentType();
  559.                 contentTypeRisposta = msg.getContentType();
  560.                 if (contentTypeRisposta != null) {
  561.                     res.setContentType(contentTypeRisposta);
  562.                     TransportUtils.setHeader(trasporto,HttpConstants.CONTENT_TYPE, contentTypeRisposta);
  563.                 }
  564.             }
  565.         }catch(Throwable error){
  566.             log.error("Errore durante la serializzazione del contentType: "+error.getMessage(),error);
  567.             try{
  568.                 throw new ConnectorException(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(error.getMessage())
  569.                         .getDescrizione(protocolFactory),error);
  570.             }catch(Throwable eInternal){
  571.                 // rilancio eccezione originale
  572.                 throw new ConnectorException(error.getMessage(),error);
  573.             }
  574.         }
  575.     
  576.         boolean consume = false; // può essere usato nel post out response handler
  577.         try{
  578.             res.sendResponse(msg, consume);
  579.         }catch(Throwable error){
  580.             log.error("Errore durante la serializzazione dell'errore: "+error.getMessage(),error);
  581.             try{
  582.                 throw new ConnectorException(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(error.getMessage())
  583.                         .getDescrizione(protocolFactory),error);
  584.             }catch(Throwable eInternal){
  585.                 // rilancio eccezione originale
  586.                 throw new ConnectorException(error.getMessage(),error);
  587.             }
  588.         }finally {
  589.             res.flush(false);
  590.             res.close(false);
  591.         }
  592.         
  593.     }
  594. }
Created with JaCoCo 0.8.8.202204050719