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



  23. package org.openspcoop2.pdd.services.service;

  25. import java.util.ArrayList;
  26. import java.util.Date;
  27. import java.util.HashMap;
  28. import java.util.Iterator;
  29. import java.util.List;
  30. import java.util.Map;

  32. import javax.xml.soap.SOAPBody;
  33. import javax.xml.soap.SOAPElement;

  35. import org.apache.commons.lang.StringUtils;
  36. import org.openspcoop2.core.config.DumpConfigurazione;
  37. import org.openspcoop2.core.config.PortaDelegata;
  38. import org.openspcoop2.core.constants.TipoPdD;
  39. import org.openspcoop2.core.constants.TransferLengthModes;
  40. import org.openspcoop2.core.id.IDPortaDelegata;
  41. import org.openspcoop2.core.id.IDServizio;
  42. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  43. import org.openspcoop2.core.transazioni.Transazione;
  44. import org.openspcoop2.message.OpenSPCoop2Message;
  45. import org.openspcoop2.message.OpenSPCoop2MessageParseResult;
  46. import org.openspcoop2.message.constants.MessageRole;
  47. import org.openspcoop2.message.constants.MessageType;
  48. import org.openspcoop2.message.constants.ServiceBinding;
  49. import org.openspcoop2.message.exception.ParseException;
  50. import org.openspcoop2.message.exception.ParseExceptionUtils;
  51. import org.openspcoop2.message.soap.SoapUtils;
  52. import org.openspcoop2.message.soap.TunnelSoapUtils;
  53. import org.openspcoop2.monitor.sdk.transaction.FaseTracciamento;
  54. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  55. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  56. import org.openspcoop2.pdd.core.CostantiPdD;
  57. import org.openspcoop2.pdd.core.GestoreRichieste;
  58. import org.openspcoop2.pdd.core.PdDContext;
  59. import org.openspcoop2.pdd.core.connettori.IConnettore;
  60. import org.openspcoop2.pdd.core.connettori.RepositoryConnettori;
  61. import org.openspcoop2.pdd.core.controllo_traffico.SogliaDimensioneMessaggio;
  62. import org.openspcoop2.pdd.core.controllo_traffico.SogliaReadTimeout;
  63. import org.openspcoop2.pdd.core.controllo_traffico.SoglieDimensioneMessaggi;
  64. import org.openspcoop2.pdd.core.credenziali.Credenziali;
  65. import org.openspcoop2.pdd.core.handlers.GestoreHandlers;
  66. import org.openspcoop2.pdd.core.handlers.HandlerException;
  67. import org.openspcoop2.pdd.core.handlers.PostOutResponseContext;
  68. import org.openspcoop2.pdd.core.handlers.PreInAcceptRequestContext;
  69. import org.openspcoop2.pdd.core.handlers.PreInRequestContext;
  70. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  71. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  72. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  73. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  74. import org.openspcoop2.pdd.logger.transazioni.ConfigurazioneTracciamento;
  75. import org.openspcoop2.pdd.logger.transazioni.InformazioniTransazione;
  76. import org.openspcoop2.pdd.logger.transazioni.TracciamentoManager;
  77. import org.openspcoop2.pdd.services.DirectVMProtocolInfo;
  78. import org.openspcoop2.pdd.services.DumpRaw;
  79. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  80. import org.openspcoop2.pdd.services.ServicesUtils;
  81. import org.openspcoop2.pdd.services.connector.ConnectorDispatcherErrorInfo;
  82. import org.openspcoop2.pdd.services.connector.ConnectorDispatcherInfo;
  83. import org.openspcoop2.pdd.services.connector.ConnectorDispatcherUtils;
  84. import org.openspcoop2.pdd.services.connector.ConnectorException;
  85. import org.openspcoop2.pdd.services.connector.RicezioneContenutiApplicativiHTTPtoSOAPConnector;
  86. import org.openspcoop2.pdd.services.connector.messages.ConnectorInMessage;
  87. import org.openspcoop2.pdd.services.connector.messages.ConnectorOutMessage;
  88. import org.openspcoop2.pdd.services.connector.messages.DirectVMConnectorInMessage;
  89. import org.openspcoop2.pdd.services.connector.messages.DirectVMConnectorOutMessage;
  90. import org.openspcoop2.pdd.services.connector.messages.DumpRawConnectorInMessage;
  91. import org.openspcoop2.pdd.services.connector.messages.DumpRawConnectorOutMessage;
  92. import org.openspcoop2.pdd.services.core.RicezioneContenutiApplicativi;
  93. import org.openspcoop2.pdd.services.core.RicezioneContenutiApplicativiContext;
  94. import org.openspcoop2.pdd.services.error.RicezioneContenutiApplicativiInternalErrorGenerator;
  95. import org.openspcoop2.protocol.basic.builder.EsitoBuilder;
  96. import org.openspcoop2.protocol.basic.registry.ServiceIdentificationReader;
  97. import org.openspcoop2.protocol.engine.SecurityTokenUtilities;
  98. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  99. import org.openspcoop2.protocol.sdk.builder.EsitoTransazione;
  100. import org.openspcoop2.protocol.sdk.builder.InformazioniErroriInfrastrutturali;
  101. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  102. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  103. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  104. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  105. import org.openspcoop2.protocol.sdk.constants.IDService;
  106. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  107. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  108. import org.openspcoop2.protocol.sdk.state.URLProtocolContext;
  109. import org.openspcoop2.protocol.utils.EsitiProperties;
  110. import org.openspcoop2.utils.LimitExceededIOException;
  111. import org.openspcoop2.utils.LoggerWrapperFactory;
  112. import org.openspcoop2.utils.TimeoutIOException;
  113. import org.openspcoop2.utils.Utilities;
  114. import org.openspcoop2.utils.date.DateManager;
  115. import org.openspcoop2.utils.dch.MailcapActivationReader;
  116. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  117. import org.openspcoop2.utils.io.notifier.NotifierInputStreamParams;
  118. import org.openspcoop2.utils.transport.TransportRequestContext;
  119. import org.openspcoop2.utils.transport.TransportUtils;
  120. import org.openspcoop2.utils.transport.http.HttpConstants;
  121. import org.slf4j.Logger;

  123. /**
  124.  * Servlet che serve per creare un tunnel da un servizio che non conosce SOAP verso OpenSPCoop (che utilizza SOAP)
  125.  *
  126.  * @author Poli Andrea (apoli@link.it)
  127.  * @author $Author$
  128.  * @version $Rev$, $Date$
  129.  */

  131. public class RicezioneContenutiApplicativiHTTPtoSOAPService  {

  133.     private RicezioneContenutiApplicativiInternalErrorGenerator generatoreErrore;
  134.     
  135.     public static void forceXmlResponse(RicezioneContenutiApplicativiInternalErrorGenerator generatoreErrore) {
  136.         generatoreErrore.setForceMessageTypeResponse(MessageType.XML); // forzo xml
  137.         if(generatoreErrore.getProprietaErroreAppl()!=null) {
  138.             generatoreErrore.getProprietaErroreAppl().setFaultAsXML(true); // siamo in una richiesta http senza SOAP, un SoapFault non ha senso
  139.         }
  140.     }
  141.     
  142.     public RicezioneContenutiApplicativiHTTPtoSOAPService(RicezioneContenutiApplicativiInternalErrorGenerator generatoreErrore){
  143.         this.generatoreErrore = generatoreErrore;
  144.         if(this.generatoreErrore!=null) {
  145.             RicezioneContenutiApplicativiHTTPtoSOAPService.forceXmlResponse(this.generatoreErrore);
  146.         }
  147.     }
  148.     
  149.     public void process(ConnectorInMessage req, ConnectorOutMessage res, Date dataAccettazioneRichiesta) throws ConnectorException {
  150.         
  151.         // Timestamp
  152.         Date dataIngressoRichiesta = null;
  153.         
  154.         // IDModulo
  155.         String idModulo = req.getIdModulo();
  156.         IDService idModuloAsService = req.getIdModuloAsIDService();
  157.         RequestInfo requestInfo = req.getRequestInfo();

  159.         // Log
  160.         Logger logCore = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  161.         if(logCore==null)
  162.             logCore = LoggerWrapperFactory.getLogger(idModulo);

  164.         OpenSPCoop2Properties openSPCoopProperties = OpenSPCoop2Properties.getInstance();
  165.         

  167.         /* ------------  PreInHandler (PreInAcceptRequestContext) ------------- */
  168.         
  169.         PreInAcceptRequestContext preInAcceptRequestContext = null;
  170.         if (openSPCoopProperties != null && OpenSPCoop2Startup.initialize) {
  171.             
  172.             // build context
  173.             preInAcceptRequestContext = new PreInAcceptRequestContext();
  174.             preInAcceptRequestContext.setTipoPorta(TipoPdD.DELEGATA);
  175.             preInAcceptRequestContext.setIdModulo(idModulo);
  176.             preInAcceptRequestContext.setRequestInfo(requestInfo);  
  177.             preInAcceptRequestContext.setLogCore(logCore);
  178.             
  179.             // valori che verranno aggiornati dopo
  180.             try {
  181.                 if(openSPCoopProperties.isConnettoriUseLimitedInputStream()) {
  182.                     SogliaDimensioneMessaggio soglia = new SogliaDimensioneMessaggio();
  183.                     soglia.setSogliaKb(openSPCoopProperties.getLimitedInputStreamThresholdKb());
  184.                     soglia.setUseContentLengthHeader(openSPCoopProperties.isLimitedInputStreamUseContentLength());
  185.                     soglia.setUseContentLengthHeaderAcceptZeroValue(openSPCoopProperties.isLimitedInputStreamUseContentLengthAcceptZeroValue());
  186.                     soglia.setPolicyGlobale(true);
  187.                     soglia.setNomePolicy("GovWayCore");
  188.                     soglia.setIdPolicyConGruppo("GovWayCore");
  189.                     req.setRequestLimitedStream(soglia);
  190.                 }
  191.                 if(openSPCoopProperties.isConnettoriUseTimeoutInputStream()) {
  192.                     SogliaReadTimeout soglia = new SogliaReadTimeout();
  193.                     soglia.setSogliaMs(openSPCoopProperties.getReadConnectionTimeout_ricezioneContenutiApplicativi());
  194.                     soglia.setConfigurazioneGlobale(true);
  195.                     soglia.setIdConfigurazione("GovWayCore");
  196.                     req.setRequestReadTimeout(soglia);
  197.                 }
  198.                 req.setThresholdContext(null, 
  199.                     openSPCoopProperties.getDumpBinarioInMemoryThreshold(), openSPCoopProperties.getDumpBinarioRepository());
  200.             }catch(Throwable t) {
  201.                 logCore.error(t.getMessage(),t);
  202.             }
  203.             preInAcceptRequestContext.setReq(req);
  204.             
  205.             // invocazione handler
  206.             GestoreHandlers.preInRequest(preInAcceptRequestContext, logCore, logCore);
  207.             
  208.         }
  209.         
  210.         
  211.         // GeneratoreErrore
  212.         try{
  213.             if(this.generatoreErrore==null){
  214.                 this.generatoreErrore = 
  215.                         new RicezioneContenutiApplicativiInternalErrorGenerator(logCore, RicezioneContenutiApplicativiHTTPtoSOAPConnector.ID_MODULO, requestInfo);
  216.                 this.generatoreErrore.getProprietaErroreAppl().setFaultAsXML(true); // siamo in una richiesta http senza SOAP, un SoapFault non ha senso
  217.             }
  218.         }catch(Exception e){
  219.             String msg = "Inizializzazione Generatore Errore fallita: "+Utilities.readFirstErrorValidMessageFromException(e);
  220.             logCore.error(msg,e);
  221.             ConnectorDispatcherErrorInfo cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore, // il metodo doError gestisce il generatoreErrore a null
  222.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  223.                     get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA), 
  224.                     IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, e, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  225.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(logCore, req, null, dataAccettazioneRichiesta, cInfo);
  226.             return;
  227.         }
  228.         
  229.         //  Proprieta' OpenSPCoop
  230.         if (!OpenSPCoop2Startup.initialize || openSPCoopProperties == null) {
  231.             String msg = "Inizializzazione di GovWay non correttamente effettuata: OpenSPCoopProperties";
  232.             if(!OpenSPCoop2Startup.initialize) {
  233.                 msg = "Inizializzazione di GovWay non correttamente effettuata";
  234.             }
  235.             logCore.error(msg);
  236.             ConnectorDispatcherErrorInfo cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore, 
  237.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  238.                         get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA), 
  239.                         IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, null, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  240.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(logCore, req, null, dataAccettazioneRichiesta, cInfo);
  241.             return;
  242.         }
  243.         
  244.         // Configurazione Reader
  245.         ConfigurazionePdDManager configPdDManager = null;
  246.         try{
  247.             configPdDManager = ConfigurazionePdDManager.getInstance();
  248.             if(configPdDManager==null || configPdDManager.isInitializedConfigurazionePdDReader()==false){
  249.                 throw new Exception("ConfigurazionePdDManager not initialized");
  250.             }
  251.         }catch(Throwable e){
  252.             String msg = "Inizializzazione di GovWay non correttamente effettuata: ConfigurazionePdDManager";
  253.             logCore.error(msg);
  254.             ConnectorDispatcherErrorInfo cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore, 
  255.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  256.                         get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA), 
  257.                         IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, e, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  258.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(logCore, req, null, dataAccettazioneRichiesta, cInfo);
  259.             return;
  260.         }
  261.             
  262.         // PddContext from servlet
  263.         Object oPddContextFromServlet = null;
  264.         try{
  265.             oPddContextFromServlet = req.getAttribute(CostantiPdD.OPENSPCOOP2_PDD_CONTEXT_HEADER_HTTP.getValue());
  266.         }catch(Exception e){
  267.             logCore.error("req.getAttribute("+CostantiPdD.OPENSPCOOP2_PDD_CONTEXT_HEADER_HTTP+") error: "+e.getMessage(),e);
  268.         }
  269.         PdDContext pddContextFromServlet = null;
  270.         if(oPddContextFromServlet!=null){
  271.             pddContextFromServlet = (PdDContext) oPddContextFromServlet;
  272.         }
  273.                 
  274.         // check requestInfo
  275.         if(requestInfo==null) {
  276.             String msg = "RequestInfo undefined";
  277.             logCore.error(msg);
  278.             return;
  279.         }
  280.         
  281.         // Identifico Servizio per comprendere correttamente il messageType
  282.         ServiceIdentificationReader serviceIdentificationReader = null;
  283.         try{
  284.             serviceIdentificationReader = ServicesUtils.getServiceIdentificationReader(logCore, requestInfo,
  285.                     configPdDManager.getRegistroServiziManager(), configPdDManager);
  286.         }catch(Exception e){
  287.             String msg = "Inizializzazione RegistryReader fallita: "+Utilities.readFirstErrorValidMessageFromException(e);
  288.             logCore.error(msg,e);
  289.             ConnectorDispatcherErrorInfo cInfo =  ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore,
  290.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  291.                         get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA),
  292.                         IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, e, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  293.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfo);
  294.             return;
  295.         }
  296.     
  297.         // Provo a creare un context (per l'id di transazione nei diagnostici)
  298.         RicezioneContenutiApplicativiContext context = null;
  299.         IProtocolFactory<?> protocolFactory = null;
  300.         String idTransazione = null;
  301.         try {
  302.             context = new RicezioneContenutiApplicativiContext(idModuloAsService,dataAccettazioneRichiesta,requestInfo);
  303.             protocolFactory = req.getProtocolFactory();
  304.             idTransazione = (String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  305.         }catch(Throwable e) {
  306.             context = null;
  307.             protocolFactory = null;
  308.             // non loggo l'errore tanto poi provo a ricreare il context subito dopo e li verra' registrato l'errore
  309.         }

  311.         try{
  312.             GestoreRichieste.readRequestConfig(requestInfo);
  313.         }catch(Exception e){
  314.             String msg = "GestoreRichieste readRequestConfig fallita: "+Utilities.readFirstErrorValidMessageFromException(e);
  315.             logCore.error(msg,e);
  316.             ConnectorDispatcherErrorInfo cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore,
  317.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  318.                         get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_500_ERRORE_INTERNO),
  319.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, e, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  320.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfo);
  321.             return;
  322.         }
  323.         
  324.         if(idTransazione!=null) {
  325.             try {
  326.                 if(openSPCoopProperties.isTransazioniEnabled()) {
  327.                     TransactionContext.createTransaction(idTransazione,"RicezioneContenutiApplicativiHTTPtoSOAP.1");
  328.                 }
  329.                 requestInfo.setIdTransazione(idTransazione);
  330.                 
  331.                 req.setThresholdContext((context!=null ? context.getPddContext(): null), 
  332.                         openSPCoopProperties.getDumpBinarioInMemoryThreshold(), openSPCoopProperties.getDumpBinarioRepository());
  333.             
  334.             }catch(Throwable e) {
  335.                 context = null;
  336.                 protocolFactory = null;
  337.                 // non loggo l'errore tanto poi provo a ricreare il context subito dopo e li verra' registrato l'errore
  338.             }
  339.         }
  340.         
  341.         // Logger dei messaggi diagnostici
  342.         String nomePorta = requestInfo.getProtocolContext().getInterfaceName();
  343.         MsgDiagnostico msgDiag = MsgDiagnostico.newInstance(TipoPdD.DELEGATA,idModulo,nomePorta,requestInfo);
  344.         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_CONTENUTI_APPLICATIVI);
  345.         if(context!=null && protocolFactory!=null) {
  346.             msgDiag.setPddContext(context.getPddContext(), protocolFactory);
  347.         }
  348.         
  349.         try{
  350.             msgDiag.logPersonalizzato("ricezioneRichiesta.firstLog");
  351.         }catch(Exception e){
  352.             logCore.error("Errore generazione diagnostico di ingresso",e);
  353.         }
  354.         
  355.         try{
  356.             req.setDiagnosticProducer(context!=null ? context.getPddContext(): null, msgDiag);
  357.         }catch(Throwable e){
  358.             logCore.error("Errore registrazione diagnostico sulla richiesta",e);
  359.         }
  360.         
  361.         // emitDiagnostic preAccept handler
  362.         GestoreHandlers.emitDiagnostic(msgDiag, preInAcceptRequestContext, context!=null ? context.getPddContext() : null, 
  363.                 logCore, logCore);
  364.         
  365.         // Aggiorno RequestInfo
  366.         try{
  367.             msgDiag.mediumDebug("Accesso configurazione della richiesta in corso...");
  368.         }catch(Exception e){
  369.             logCore.error("Errore generazione diagnostico",e);
  370.         }
  371.         ConnectorDispatcherInfo cInfo = RicezioneContenutiApplicativiServiceUtils.updatePortaDelegataRequestInfo(requestInfo, logCore, req, res,
  372.                 this.generatoreErrore, serviceIdentificationReader, msgDiag, 
  373.                 context!=null ? context.getPddContext(): null);
  374.         if(cInfo!=null){
  375.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(context, logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfo);
  376.             return; // l'errore in response viene impostato direttamente dentro il metodo
  377.         }
  378.         req.updateRequestInfo(requestInfo); 

  380.         // Timeout e DumpRaw
  381.         DumpRaw dumpRaw = null;
  382.         try{
  383.             try{
  384.                 msgDiag.mediumDebug("Lettura configurazione dump binario ...");
  385.             }catch(Exception e){
  386.                 logCore.error("Errore generazione diagnostico",e);
  387.             }
  388.             boolean dumpBinario = configPdDManager.dumpBinarioPD();
  389.             PortaDelegata pd = null;
  390.             if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  391.                 IDPortaDelegata idPD = new IDPortaDelegata();
  392.                 idPD.setNome(requestInfo.getProtocolContext().getInterfaceName());
  393.                 pd = configPdDManager.getPortaDelegataSafeMethod(idPD, requestInfo);
  394.             }

  396.             // Limited
  397.             try{
  398.                 msgDiag.mediumDebug("Lettura configurazione dimensione massima della richiesta ...");
  399.             }catch(Exception e){
  400.                 logCore.error("Errore generazione diagnostico",e);
  401.             }
  402.             String azione = (requestInfo!=null && requestInfo.getIdServizio()!=null) ? requestInfo.getIdServizio().getAzione() : null;
  403.             SoglieDimensioneMessaggi limitedInputStream = configPdDManager.getSoglieLimitedInputStream(pd, azione, idModulo,
  404.                     (context!=null && context.getPddContext()!=null) ? context.getPddContext() : null, 
  405.                     requestInfo,
  406.                     protocolFactory, logCore);
  407.             if(limitedInputStream!=null) {
  408.                 req.setRequestLimitedStream(limitedInputStream.getRichiesta());
  409.                 if(context!=null && context.getPddContext()!=null) {
  410.                     context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.LIMITED_STREAM, limitedInputStream.getRisposta());
  411.                 }
  412.             }
  413.             else {
  414.                 if(!openSPCoopProperties.isLimitedInputStreamThresholdDefined()) {
  415.                     req.disableLimitedStream();
  416.                 }
  417.             }
  418.             
  419.             // Timeout
  420.             try{
  421.                 msgDiag.mediumDebug("Lettura configurazione timeout per la lettura della richiesta ...");
  422.             }catch(Exception e){
  423.                 logCore.error("Errore generazione diagnostico",e);
  424.             }
  425.             boolean useTimeoutInputStream = configPdDManager.isConnettoriUseTimeoutInputStream(pd);
  426.             if(useTimeoutInputStream) {
  427.                 SogliaReadTimeout timeout = configPdDManager.getRequestReadTimeout(pd,
  428.                         requestInfo,
  429.                         protocolFactory, 
  430.                         context!=null ? context.getPddContext() : null,
  431.                                 null);
  432.                 if(timeout!=null && timeout.getSogliaMs()>0) {
  433.                     req.setRequestReadTimeout(timeout);
  434.                 }
  435.                 else {
  436.                     req.disableReadTimeout();
  437.                 }
  438.             }
  439.             else {
  440.                 req.disableReadTimeout();
  441.             }
  442.             
  443.             // DumpRaw
  444.             try{
  445.                 msgDiag.mediumDebug("Lettura configurazione dump ...");
  446.             }catch(Exception e){
  447.                 logCore.error("Errore generazione diagnostico",e);
  448.             }
  449.             DumpConfigurazione dumpConfigurazione = configPdDManager.getDumpConfigurazione(pd);
  450.             ConfigurazioneTracciamento configurazioneTracciamento = new ConfigurazioneTracciamento(logCore, configPdDManager, pd);
  451.             boolean fileTraceHeaders = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioHeaderEnabled();
  452.             boolean fileTracePayload = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioPayloadEnabled();
  453.             dumpRaw = new DumpRaw(logCore, requestInfo.getIdentitaPdD(), idModulo, TipoPdD.DELEGATA, 
  454.                     dumpBinario, 
  455.                     dumpConfigurazione,
  456.                     fileTraceHeaders, fileTracePayload);
  457.             if(dumpRaw.isActiveDumpRichiesta()) {
  458.                 req = new DumpRawConnectorInMessage(logCore, req, 
  459.                         (context!=null ? context.getPddContext(): null), 
  460.                         openSPCoopProperties.getDumpBinarioInMemoryThreshold(), openSPCoopProperties.getDumpBinarioRepository());
  461.             }
  462.             if(dumpRaw.isActiveDumpRisposta()) {
  463.                 res = new DumpRawConnectorOutMessage(logCore, res, 
  464.                         (context!=null ? context.getPddContext(): null), 
  465.                         openSPCoopProperties.getDumpBinarioInMemoryThreshold(), openSPCoopProperties.getDumpBinarioRepository(),
  466.                         dumpRaw);
  467.             }
  468.         }catch(Throwable e){
  469.             String msg = "Inizializzazione di GovWay non correttamente effettuata: DumpRaw";
  470.             logCore.error(msg,  e);
  471.             cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore, 
  472.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  473.                         get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA), 
  474.                         IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, e, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  475.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfo);
  476.             return;
  477.         }
  478.         
  479.         // Questo servizio è invocabile solo con API Soap
  480.         if(!ServiceBinding.SOAP.equals(requestInfo.getIntegrationServiceBinding())){
  481.             String msg = "Servizio utilizzabile solamente con API SOAP, riscontrata API REST";
  482.             logCore.error(msg);
  483.             ConnectorDispatcherErrorInfo cInfoError =  ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore,
  484.                     ErroriIntegrazione.ERRORE_439_FUNZIONALITA_NOT_SUPPORTED_BY_PROTOCOL.getErrore439_FunzionalitaNotSupportedByProtocol(msg, protocolFactory),
  485.                     IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL, null, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  486.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(context, logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfoError);
  487.             return;
  488.         }
  489.         
  490.         
  491.         
  492.         
  493.         
  494.         
  495.         /* ------------  Lettura parametri della richiesta ------------- */
  496.         
  497.         // PostOutResponseContext
  498.         PostOutResponseContext postOutResponseContext = null;
  499.         
  500.         PdDContext pddContext = null;
  501.         String errorImbustamentoSoapNonRiuscito = null;
  502.         MessageType messageTypeReq = null;
  503.         OpenSPCoop2Message requestMessage = null;
  504.         OpenSPCoop2Message responseMessage = null;
  505.         String protocol = null;
  506.         byte[] inputBody = null;
  507.         
  508.         try{
  509.             
  510.             /* --------------- Creo il context che genera l'id univoco ----------------------- */
  511.             
  512.             try{
  513.                 msgDiag.mediumDebug("Creazione contesto ...");
  514.             }catch(Exception e){
  515.                 logCore.error("Errore generazione diagnostico",e);
  516.             }
  517.             
  518.             if(protocolFactory==null) {
  519.                 protocolFactory = req.getProtocolFactory();
  520.             }
  521.             protocol = protocolFactory.getProtocol();
  522.             
  523.             if(context==null) {
  524.                 context = new RicezioneContenutiApplicativiContext(idModuloAsService,dataAccettazioneRichiesta,requestInfo);
  525.             }
  526.             if(preInAcceptRequestContext!=null && preInAcceptRequestContext.getPreContext()!=null && !preInAcceptRequestContext.getPreContext().isEmpty()) {
  527.                 context.getPddContext().addAll(preInAcceptRequestContext.getPreContext(), false);
  528.             }
  529.             context.setTipoPorta(TipoPdD.DELEGATA);
  530.             context.setForceFaultAsXML(true); // siamo in una richiesta http senza SOAP, un SoapFault non ha senso
  531.             context.setIdModulo(idModulo);
  532.             context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME, protocolFactory.getProtocol());
  533.             context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO, req.getRequestInfo());
  534.             RicezionePropertiesConfig rConfig = RicezioneContenutiApplicativiServiceUtils.readPropertiesConfig(req.getRequestInfo(), logCore,null);
  535.             if(rConfig!=null) {
  536.                 if (rConfig.getApiImplementation() != null && !rConfig.getApiImplementation().isEmpty()) {
  537.                    context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_CONFIGURAZIONE, rConfig.getApiImplementation());
  538.                 }
  539.                 if (rConfig.getSoggettoFruitore() != null && !rConfig.getSoggettoFruitore().isEmpty()) {
  540.                     context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_FRUITORE, rConfig.getSoggettoFruitore());
  541.                 }
  542.                 if (rConfig.getSoggettoErogatore() != null && !rConfig.getSoggettoErogatore().isEmpty()) {
  543.                     context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_EROGATORE, rConfig.getSoggettoErogatore());
  544.                 }
  545.             }
  546.             msgDiag.setPddContext(context.getPddContext(),protocolFactory);     
  547.             pddContext = context.getPddContext();
  548.             
  549.             try{
  550.                 if(openSPCoopProperties.isTransazioniEnabled()) {
  551.                     // NOTA: se gia' esiste con l'id di transazione, non viene ricreata
  552.                     TransactionContext.createTransaction((String)pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE),"RicezioneContenutiApplicativiHTTPtoSOAP.2");
  553.                 }
  554.             }catch(Exception e){
  555.                 logCore.error("Errore durante la creazione della transazione",e);
  556.             }
  557.             
  558.             try{
  559.                 msgDiag.logPersonalizzato("ricezioneRichiesta.firstAccessRequestStream");
  560.             }catch(Exception e){
  561.                 logCore.error("Errore generazione diagnostico di ingresso (stream access)",e);
  562.             }
  563.             
  564.             if(dumpRaw!=null && dumpRaw.isActiveDump()){
  565.                 dumpRaw.setPddContext(msgDiag.getPorta(), context.getPddContext());
  566.                 dumpRaw.serializeContext(context, protocol);
  567.             }
  568.             
  569.             DirectVMConnectorInMessage vm = null;
  570.             if(req instanceof DirectVMConnectorInMessage){
  571.                 vm = (DirectVMConnectorInMessage) req;
  572.             }
  573.             else if(req instanceof DumpRawConnectorInMessage){
  574.                 if( ((DumpRawConnectorInMessage)req).getWrappedConnectorInMessage() instanceof DirectVMConnectorInMessage ){
  575.                     vm = (DirectVMConnectorInMessage) ((DumpRawConnectorInMessage)req).getWrappedConnectorInMessage();
  576.                 }
  577.             }
  578.             if(vm!=null && vm.getDirectVMProtocolInfo()!=null){
  579.                 vm.getDirectVMProtocolInfo().setInfo(pddContext);
  580.             }
  581.             
  582.             
  583.             
  584.             
  585.             /* ------------  PostOutResponseContext ------------- */
  586.             postOutResponseContext = new PostOutResponseContext(logCore,protocolFactory);
  587.             postOutResponseContext.setTipoPorta(TipoPdD.DELEGATA);
  588.             postOutResponseContext.setPddContext(pddContext);
  589.             postOutResponseContext.setIdModulo(idModulo);
  590.             
  591.             
  592.             
  593.             
  594.             /* ------------  PreInHandler ------------- */
  595.             
  596.             // build context
  597.             PreInRequestContext preInRequestContext = new PreInRequestContext(pddContext);
  598.             if(pddContextFromServlet!=null){
  599.                 preInRequestContext.getPddContext().addAll(pddContextFromServlet, true);
  600.             }
  601.             preInRequestContext.setTipoPorta(TipoPdD.DELEGATA);
  602.             preInRequestContext.setIdModulo(idModulo);
  603.             preInRequestContext.setProtocolFactory(protocolFactory);
  604.             preInRequestContext.setRequestInfo(requestInfo);
  605.             Map<String, Object> transportContext = new HashMap<>();
  606.             transportContext.put(PreInRequestContext.SERVLET_REQUEST, req);
  607.             transportContext.put(PreInRequestContext.SERVLET_RESPONSE, res);
  608.             preInRequestContext.setTransportContext(transportContext);  
  609.             preInRequestContext.setLogCore(logCore);
  610.             
  611.             // invocazione handler
  612.             GestoreHandlers.preInRequest(preInRequestContext, msgDiag, logCore);
  613.             
  614.             // aggiungo eventuali info inserite nel preInHandler
  615.             pddContext.addAll(preInRequestContext.getPddContext(), false);
  616.             
  617.             // Lettura risposta parametri NotifierInputStream
  618.             NotifierInputStreamParams notifierInputStreamParams = preInRequestContext.getNotifierInputStreamParams();
  619.             context.setNotifierInputStreamParams(notifierInputStreamParams);
  620.             
  621.             // Controllo Content Length se attiva una policy di rate limiting
  622.             req.checkContentLengthLimit();
  623.             
  624.             // Lettura richiesta con il dump
  625.             if(dumpRaw!=null && dumpRaw.isActiveDumpRichiesta()){
  626.                 dumpRaw.serializeRequest(((DumpRawConnectorInMessage)req), false, notifierInputStreamParams);
  627.                 dataIngressoRichiesta = req.getDataIngressoRichiesta();
  628.                 context.setDataIngressoRichiesta(dataIngressoRichiesta);
  629.             }

  631.             
  632.             
  633.             


  636.             
  637.             
  638.             
  639.             
  640.             /* ------------ Controllo ContentType -------------------- */
  641.             
  642.             msgDiag.logPersonalizzato("ricezioneRichiesta.elaborazioneDati.tipologiaMessaggio");
  643.             messageTypeReq = MessageType.SOAP_11; // rendere parametrico ?
  644.             
  645.             
  646.             
  647.             
  648.             /* ------------  Imbustamento Messaggio di Richiesta ------------- */
  649.             boolean imbustamentoConAttachment = false;
  650.             String tipoAttachment =  HttpConstants.CONTENT_TYPE_OPENSPCOOP2_TUNNEL_SOAP;
  651.             // HeaderTrasporto
  652.             String imb = TransportUtils.getFirstValue(req.getHeaderValues(openSPCoopProperties.getTunnelSOAPKeyWord_headerTrasporto()));
  653.             if(imb!=null && "true".equals(imb.trim())){
  654.                 imbustamentoConAttachment = true;
  655.                 String mime = TransportUtils.getFirstValue(req.getHeaderValues(openSPCoopProperties.getTunnelSOAPKeyWordMimeType_headerTrasporto()));
  656.                 if(mime!=null) {
  657.                     tipoAttachment = mime.trim();
  658.                 }
  659.             }
  660.             if(imb==null){
  661.                 // Proprieta FORMBased
  662.                 imb = TransportUtils.getFirstValue(req.getParameterValues(openSPCoopProperties.getTunnelSOAPKeyWord_urlBased()));
  663.                 if(imb!=null && "true".equals(imb.trim())){
  664.                     imbustamentoConAttachment = true;
  665.                     // lettura eventuale tipo di attachment
  666.                     String mime = TransportUtils.getFirstValue(req.getParameterValues(openSPCoopProperties.getTunnelSOAPKeyWordMimeType_urlBased())); 
  667.                     if(mime!=null){
  668.                         tipoAttachment = mime.trim();
  669.                     }
  670.                 }
  671.             }
  672.             if(imb==null){
  673.                 // Vedo se fosse indicato nel transport Context
  674.                 if(transportContext.get(openSPCoopProperties.getTunnelSOAPKeyWord_urlBased())!=null){
  675.                     if("true".equalsIgnoreCase((String)transportContext.get(openSPCoopProperties.getTunnelSOAPKeyWord_urlBased()))){
  676.                         imbustamentoConAttachment = true;
  677.                         // lettura eventuale tipo di attachment
  678.                         if(transportContext.get(openSPCoopProperties.getTunnelSOAPKeyWordMimeType_urlBased())!=null){
  679.                             tipoAttachment = (String) transportContext.get(openSPCoopProperties.getTunnelSOAPKeyWordMimeType_urlBased());
  680.                         }
  681.                     }
  682.                 }
  683.             }

  685.             String tipoLetturaRisposta = null;
  686.             try{
  687.                 Utilities.printFreeMemory("RicezioneContenutiApplicativiHTTPtoSOAP - Pre costruzione richiesta");
  688.                 msgDiag.logPersonalizzato("ricezioneRichiesta.elaborazioneDati.inCorso");
  689.                 DumpByteArrayOutputStream bout = req.getRequest();
  690.                 if(bout!=null && bout.size()>0) {
  691.                     inputBody = bout.toByteArray();
  692.                     bout.clearResources();
  693.                     bout=null;
  694.                 }
  695.                 if( inputBody == null || inputBody.length<=0 ){
  696.                     throw new Exception("Ricevuto nessun contenuto da imbustare");
  697.                 }
  698.                 req.close();
  699.                 dataIngressoRichiesta = req.getDataIngressoRichiesta();
  700.                 context.setDataIngressoRichiesta(dataIngressoRichiesta);
  701.                 
  702.                 if(imbustamentoConAttachment){
  703.                     tipoLetturaRisposta = "Costruzione messaggio SOAP per Tunnel con mimeType "+tipoAttachment;
  704.                     requestMessage = TunnelSoapUtils.imbustamentoMessaggioConAttachment(org.openspcoop2.pdd.core.Utilities.getOpenspcoop2MessageFactory(logCore,requestInfo, MessageRole.REQUEST),
  705.                             messageTypeReq,MessageRole.REQUEST,inputBody,tipoAttachment,
  706.                             MailcapActivationReader.existsDataContentHandler(tipoAttachment),req.getContentType(), openSPCoopProperties.getHeaderSoapActorIntegrazione());                  
  707.                     requestMessage.setTransportRequestContext(requestInfo.getProtocolContext());                
  708.                 }else{
  709.                     tipoLetturaRisposta = "Imbustamento messaggio in un messaggio SOAP";
  710.                     String contentTypeForEnvelope = null; // todo renderlo parametrico soprattutto per soap1.2
  711.                     //String soapAction = "\"OpenSPCoop2\""; // todo renderlo parametrico
  712.                     String soapAction = "\"GovWay\""; // todo renderlo parametrico
  713.                     OpenSPCoop2MessageParseResult pr = org.openspcoop2.pdd.core.Utilities.getOpenspcoop2MessageFactory(logCore,requestInfo, MessageRole.REQUEST).
  714.                             envelopingMessage(messageTypeReq, contentTypeForEnvelope, soapAction, 
  715.                             requestInfo.getProtocolContext(), inputBody, notifierInputStreamParams, 
  716.                             openSPCoopProperties.getAttachmentsProcessingMode(), 
  717.                             openSPCoopProperties.isDeleteInstructionTargetMachineXml(),
  718.                             openSPCoopProperties.useSoapMessageReader(), openSPCoopProperties.getSoapMessageReaderBufferThresholdKb());
  719.                     if(pr.getParseException()!=null){
  720.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, pr.getParseException());
  721.                     }
  722.                     requestMessage = pr.getMessage_throwParseException();
  723.                 }
  724.                 
  725.                 if(requestInfo.getProtocolContext().getHeaders()==null) {
  726.                     requestInfo.getProtocolContext().setHeaders(new HashMap<>());
  727.                 }
  728.                 requestInfo.getProtocolContext().removeHeader(HttpConstants.CONTENT_TYPE);
  729.                 TransportUtils.setHeader(requestInfo.getProtocolContext().getHeaders(),HttpConstants.CONTENT_TYPE, requestMessage.getContentType());
  730.                 requestInfo.setIntegrationRequestMessageType(requestMessage.getMessageType());
  731.                 
  732.                 Utilities.printFreeMemory("RicezioneContenutiApplicativiHTTPtoSOAP - Post costruzione richiesta");
  733.                 requestMessage.setProtocolName(protocolFactory.getProtocol());
  734.                 requestMessage.setTransactionId(PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext));
  735.                 requestMessage.addContextProperty(org.openspcoop2.core.constants.Costanti.REQUEST_INFO,requestInfo); // serve nelle comunicazione non stateless (es. riscontro salvato) per poterlo rispedire
  736.                 requestMessage.addContextProperty(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE,pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)); // serve nelle comunicazione non stateless (es. riscontro salvato) per poterlo rispedire
  737.                 Object nomePortaInvocataObject = context.getPddContext().getObject(CostantiPdD.NOME_PORTA_INVOCATA);
  738.                 if(nomePortaInvocataObject!=null && nomePortaInvocataObject instanceof String) {
  739.                     requestMessage.addContextProperty(CostantiPdD.NOME_PORTA_INVOCATA, (String) nomePortaInvocataObject );
  740.                 }
  741.                                 
  742.             }catch(Exception e){
  743.                 logCore.error(tipoLetturaRisposta +" con errore: "+e.getMessage(),e);
  744.                 errorImbustamentoSoapNonRiuscito=tipoLetturaRisposta +" con errore: "+e.getMessage();
  745.                 throw e;
  746.             }
  747.             
  748.             
  749.             /* --------------- SecurityToken --------------- */
  750.             try {
  751.                 if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getCredential()!=null && 
  752.                         requestInfo.getProtocolContext().getCredential().getCertificate()!=null &&
  753.                         requestInfo.getProtocolContext().getCredential().getCertificate().getCertificate()!=null) {
  754.                     SecurityTokenUtilities.newSecurityToken(pddContext);
  755.                 }
  756.             }catch(Exception e){
  757.                 logCore.error("Costruzione SecurityToken non riuscito: "+e.getMessage(),e);
  758.             }
  759.             
  760.             /* ------------  Elaborazione ------------- */
  761.         
  762.             // Contesto di Richiesta
  763.             context.setCredenziali(new Credenziali(req.getCredential()));
  764.             context.setGestioneRisposta(true); // siamo in una servlet, la risposta deve essere aspettata
  765.             context.setInvocazionePDPerRiferimento(false); // la PD con questa servlet non effettuera' mai invocazioni per riferimento.
  766.             context.setMessageRequest(requestMessage);
  767.             context.setUrlProtocolContext(requestInfo.getProtocolContext());
  768.             context.setMsgDiagnostico(msgDiag);
  769.                     
  770.             // Log elaborazione dati completata
  771.             msgDiag.logPersonalizzato("ricezioneRichiesta.elaborazioneDati.completata");
  772.             
  773.             // se il tracciamento lo prevedo emetto un log
  774.             registraTracciaInRequest(context, protocolFactory, logCore, msgDiag);
  775.             
  776.             // Invocazione...
  777.             RicezioneContenutiApplicativi gestoreRichiesta = new RicezioneContenutiApplicativi(context, this.generatoreErrore);
  778.             gestoreRichiesta.process(req);
  779.             responseMessage = context.getMessageResponse();
  780.                         
  781.         } catch (Throwable e) {
  782.             
  783.             if(context==null){
  784.                 // Errore durante la generazione dell'id
  785.                 context = RicezioneContenutiApplicativiContext.newRicezioneContenutiApplicativiContext(idModuloAsService,dataAccettazioneRichiesta,requestInfo);
  786.                 context.setDataIngressoRichiesta(dataIngressoRichiesta);
  787.                 context.setTipoPorta(TipoPdD.DELEGATA);
  788.                 context.setForceFaultAsXML(true); // siamo in una richiesta http senza SOAP, un SoapFault non ha senso
  789.                 context.setIdModulo(idModulo);
  790.                 context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME, protocolFactory.getProtocol());
  791.                 pddContext = context.getPddContext();
  792.                 msgDiag.setPddContext(pddContext,protocolFactory);
  793.                 if(postOutResponseContext!=null){
  794.                     postOutResponseContext.setPddContext(pddContext);
  795.                 }
  796.             }
  797.             
  798.             // Se viene lanciata una eccezione, riguarda la richiesta, altrimenti è gestita dopo nel finally.
  799.             Throwable tParsing = null;
  800.             ParseException parseException = null;
  801.             if(pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION)){
  802.                 parseException = (ParseException) pddContext.removeObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  803.                 if(parseException!=null) {
  804.                     tParsing = parseException.getParseException();
  805.                 }
  806.             }
  807.             if(tParsing==null && (requestMessage==null || requestMessage.getParseException() == null)){
  808.                 tParsing = ParseExceptionUtils.getParseException(e);
  809.             }
  810.                     
  811.             // Genero risposta con errore
  812.             if(errorImbustamentoSoapNonRiuscito!=null){
  813.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  814.                 logCore.error("ImbustamentoSOAP",e);
  815.                 Throwable tMessage = null;
  816.                 if(tParsing!=null){
  817.                     tMessage = tParsing;
  818.                 }
  819.                 else{
  820.                     tMessage = e;
  821.                 }
  822.                 String msgErrore = tMessage.getMessage();
  823.                 if(msgErrore==null){
  824.                     msgErrore = tMessage.toString();
  825.                 }
  826.                 msgDiag.logErroreGenerico(errorImbustamentoSoapNonRiuscito+"  "+msgErrore, "ImbustamentoSOAP");
  827.                 
  828.                 IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.UNPROCESSABLE_REQUEST_CONTENT;
  829.                 if( parseException!=null && parseException.getSourceException()!=null &&
  830.                         TimeoutIOException.isTimeoutIOException(parseException.getSourceException())) {
  831.                     integrationFunctionError = IntegrationFunctionError.REQUEST_TIMED_OUT;
  832.                 }
  833.                 else if( parseException!=null && parseException.getSourceException()!=null &&
  834.                         LimitExceededIOException.isLimitExceededIOException(parseException.getSourceException())) {
  835.                     integrationFunctionError = IntegrationFunctionError.REQUEST_SIZE_EXCEEDED;
  836.                 }
  837.                 
  838.                 responseMessage = this.generatoreErrore.build(pddContext,integrationFunctionError,
  839.                         ErroriIntegrazione.ERRORE_422_IMBUSTAMENTO_SOAP_NON_RIUSCITO_RICHIESTA_APPLICATIVA.
  840.                         getErrore422_MessaggioSOAPNonGenerabileTramiteImbustamentoSOAP(errorImbustamentoSoapNonRiuscito),tMessage,null);
  841.             }
  842.             else if(tParsing!=null){
  843.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  844.                 String msgErrore = tParsing.getMessage();
  845.                 if(msgErrore==null){
  846.                     msgErrore = tParsing.toString();
  847.                 }
  848.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  849.                 logCore.error("parsingExceptionRichiesta",e);
  850.                 msgDiag.logPersonalizzato("parsingExceptionRichiesta");
  851.                 
  852.                 IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.UNPROCESSABLE_REQUEST_CONTENT;
  853.                 if( parseException!=null && parseException.getSourceException()!=null &&
  854.                         TimeoutIOException.isTimeoutIOException(parseException.getSourceException())) {
  855.                     integrationFunctionError = IntegrationFunctionError.REQUEST_TIMED_OUT;
  856.                 }
  857.                 else if( parseException!=null && parseException.getSourceException()!=null &&
  858.                         LimitExceededIOException.isLimitExceededIOException(parseException.getSourceException())) {
  859.                     integrationFunctionError = IntegrationFunctionError.REQUEST_SIZE_EXCEEDED;
  860.                 }
  861.                 
  862.                 responseMessage = this.generatoreErrore.build(pddContext,integrationFunctionError,
  863.                         ErroriIntegrazione.ERRORE_432_PARSING_EXCEPTION_RICHIESTA.
  864.                         getErrore432_MessaggioRichiestaMalformato(tParsing),tParsing,null);
  865.             }
  866.             else if (e instanceof HandlerException) {
  867.                 logCore.error("ErroreGenerale (HandlerException)",e);
  868.                 HandlerException he = (HandlerException) e;
  869.                 if(he.isEmettiDiagnostico()) {
  870.                     msgDiag.logErroreGenerico(e, "Generale(richiesta-handler)");
  871.                 }
  872.                 ErroreIntegrazione errore = he.convertToErroreIntegrazione();
  873.                 if(errore==null) {
  874.                     errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento("Generale(richiesta)");
  875.                 }
  876.                 IntegrationFunctionError integrationError = he.getIntegrationFunctionError();
  877.                 if(integrationError==null) {
  878.                     integrationError = IntegrationFunctionError.BAD_REQUEST;
  879.                 }
  880.                 responseMessage = this.generatoreErrore.build(pddContext,integrationError,errore,e,null);
  881.                 he.customized(responseMessage);
  882.             }
  883.             else{
  884.                 logCore.error("ErroreGenerale",e);
  885.                 msgDiag.logErroreGenerico(e, "Generale(richiesta)");
  886.                 responseMessage = this.generatoreErrore.build(pddContext,IntegrationFunctionError.BAD_REQUEST,
  887.                         ErroriIntegrazione.ERRORE_426_SERVLET_ERROR.
  888.                         getErrore426_ServletError(true, e),e,null);
  889.             }
  890.         }
  891.         finally{

  893.             try {
  894.                 GestoreRichieste.saveRequestConfig(requestInfo);
  895.             }catch(Throwable e) {
  896.                 logCore.error("Errore durante il salvataggio dei dati della richiesta: "+e.getMessage(),e);
  897.             }           

  899.             if((requestMessage!=null && requestMessage.getParseException() != null) || 
  900.                     (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION))){
  901.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  902.                 ParseException parseException = null;
  903.                 if( requestMessage!=null && requestMessage.getParseException() != null ){
  904.                     parseException = requestMessage.getParseException();
  905.                 }
  906.                 else{
  907.                     parseException = (ParseException) pddContext.getObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  908.                 }
  909.                 String msgErrore = parseException.getParseException().getMessage();
  910.                 if(msgErrore==null){
  911.                     msgErrore = parseException.getParseException().toString();
  912.                 }
  913.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  914.                 logCore.error("parsingExceptionRichiesta",parseException.getSourceException());
  915.                 msgDiag.logPersonalizzato("parsingExceptionRichiesta");
  916.                 
  917.                 IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.UNPROCESSABLE_REQUEST_CONTENT;
  918.                 if( parseException!=null && parseException.getSourceException()!=null &&
  919.                         TimeoutIOException.isTimeoutIOException(parseException.getSourceException())) {
  920.                     integrationFunctionError = IntegrationFunctionError.REQUEST_TIMED_OUT;
  921.                 }
  922.                 else if( parseException!=null && parseException.getSourceException()!=null &&
  923.                         LimitExceededIOException.isLimitExceededIOException(parseException.getSourceException())) {
  924.                     integrationFunctionError = IntegrationFunctionError.REQUEST_SIZE_EXCEEDED;
  925.                 }
  926.                 
  927.                 responseMessage = this.generatoreErrore.build(pddContext, integrationFunctionError,
  928.                         ErroriIntegrazione.ERRORE_432_PARSING_EXCEPTION_RICHIESTA.
  929.                         getErrore432_MessaggioRichiestaMalformato(parseException.getParseException()),
  930.                         parseException.getParseException(),null);
  931.             }
  932.             else if( (responseMessage!=null && responseMessage.getParseException() != null) ||
  933.                     (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION))){
  934.                 if(pddContext!=null) {
  935.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO, true);
  936.                 }
  937.                 ParseException parseException = null;
  938.                 if( responseMessage!=null && responseMessage.getParseException() != null ){
  939.                     parseException = responseMessage.getParseException();
  940.                 }
  941.                 else{
  942.                     parseException = (ParseException) pddContext.getObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  943.                 }
  944.                 String msgErrore = parseException.getParseException().getMessage();
  945.                 if(msgErrore==null){
  946.                     msgErrore = parseException.getParseException().toString();
  947.                 }
  948.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  949.                 logCore.error("parsingExceptionRisposta",parseException.getSourceException());
  950.                 msgDiag.logPersonalizzato("parsingExceptionRisposta");
  951.                 responseMessage = this.generatoreErrore.build(pddContext, IntegrationFunctionError.UNPROCESSABLE_RESPONSE_CONTENT,
  952.                         ErroriIntegrazione.ERRORE_440_PARSING_EXCEPTION_RISPOSTA.
  953.                         getErrore440_MessaggioRispostaMalformato(parseException.getParseException()),
  954.                         parseException.getParseException(),null);
  955.             }
  956.             
  957.             try{
  958.                 // Se non sono stati recuperati i dati delle url, provo a recuperarli
  959.                 URLProtocolContext urlProtocolContext = context!=null ? context.getUrlProtocolContext() : null;
  960.                 if(urlProtocolContext==null){
  961.                     urlProtocolContext = req.getURLProtocolContext();
  962.                 }
  963.                 if(urlProtocolContext!=null){
  964.                     String urlInvocazione = urlProtocolContext.getUrlInvocazione_formBased();
  965.                     if(urlProtocolContext.getFunction()!=null){
  966.                         urlInvocazione = "["+urlProtocolContext.getFunction()+"] "+urlInvocazione;
  967.                     }
  968.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.URL_INVOCAZIONE, urlInvocazione);
  969.                 }
  970.             }catch(Throwable t){}
  971.             try{
  972.                 Credenziali credenziali = context!=null ? context.getCredenziali() : null;
  973.                 if(credenziali==null){
  974.                     credenziali = new Credenziali(req.getCredential());
  975.                 }
  976.                 if(credenziali!=null && pddContext!=null){
  977.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.CREDENZIALI_INVOCAZIONE, credenziali.toString());
  978.                 }
  979.             }catch(Throwable t){}
  980.             
  981.             // *** GB ***
  982.             try{
  983.                 req.close();
  984.             }catch(Exception e){
  985.                 logCore.error("Request.close() error: "+e.getMessage(),e);
  986.             }
  987.             // *** GB ***
  988.         }
  989.             
  990.             
  991.         // Imposto risposta

  993.         Date dataPrimaSpedizioneRisposta = DateManager.getDate();
  994.         Date dataRispostaSpedita = null; 
  995.         Transazione transazioneDaAggiornare = null;
  996.         
  997.         if(context.getMsgDiagnostico()!=null){
  998.             msgDiag = context.getMsgDiagnostico();
  999.         }
  1000.         if(context.getResponseHeaders()==null) {
  1001.             context.setResponseHeaders(new HashMap<>());
  1002.         }
  1003.         ServicesUtils.setGovWayHeaderResponse(requestMessage!=null ? requestMessage.getServiceBinding() : requestInfo.getProtocolServiceBinding(),
  1004.                 responseMessage, openSPCoopProperties,
  1005.                 context.getResponseHeaders(), logCore, true, context.getPddContext(), requestInfo);
  1006.         if(context.getResponseHeaders()!=null){
  1007.             Iterator<String> keys = context.getResponseHeaders().keySet().iterator();
  1008.             while (keys.hasNext()) {
  1009.                 String key = (String) keys.next();
  1010.                 List<String> values = context.getResponseHeaders().get(key);
  1011.                 if(values!=null && !values.isEmpty()) {
  1012.                     for (int i = 0; i < values.size(); i++) {
  1013.                         String value = values.get(i);
  1014.                         String verbo = "";
  1015.                         try{
  1016.                             if(i==0) {
  1017.                                 verbo = "set";
  1018.                                 res.setHeader(key,value);
  1019.                             }
  1020.                             else {
  1021.                                 verbo = "add";
  1022.                                 res.addHeader(key,value);
  1023.                             }
  1024.                         }catch(Exception e){
  1025.                             logCore.error("Response."+verbo+"Header("+key+","+value+") error: "+e.getMessage(),e);
  1026.                         }   
  1027.                     }
  1028.                 }
  1029.             }   
  1030.         }
  1031.         if(context!=null && context.getProtocol()!=null){
  1032.             
  1033.             this.generatoreErrore.updateDominio(context.getIdentitaPdD());
  1034.             
  1035.             IDServizio idServizio = null;
  1036.             try{
  1037.                 idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(context.getProtocol().getTipoServizio(), 
  1038.                         context.getProtocol().getServizio(), 
  1039.                         context.getProtocol().getErogatore(), 
  1040.                         context.getProtocol().getVersioneServizio());
  1041.             }catch(Exception e){ 
  1042.                 // non dovrebbe succedere eccezione}
  1043.             }
  1044.             if(idServizio!=null){
  1045.                 idServizio.setAzione(context.getProtocol().getAzione());
  1046.                 this.generatoreErrore.updateInformazioniCooperazione(context.getProtocol().getFruitore(), idServizio);
  1047.             }
  1048.                         
  1049.             String servizioApplicativo = null;
  1050.             if(context.getIntegrazione()!=null){
  1051.                 servizioApplicativo = context.getIntegrazione().getServizioApplicativoFruitore();
  1052.             }
  1053.             this.generatoreErrore.updateInformazioniCooperazione(servizioApplicativo);
  1054.             
  1055.             this.generatoreErrore.updateProprietaErroreApplicativo(context.getProprietaErroreAppl());
  1056.             
  1057.         }
  1058.         DirectVMConnectorOutMessage vm = null;
  1059.         if(res instanceof DirectVMConnectorOutMessage){
  1060.             vm = (DirectVMConnectorOutMessage) res;
  1061.         }
  1062.         else if(req instanceof DumpRawConnectorOutMessage){
  1063.             if( ((DumpRawConnectorOutMessage)res).getWrappedConnectorOutMessage() instanceof DirectVMConnectorOutMessage ){
  1064.                 vm = (DirectVMConnectorOutMessage) ((DumpRawConnectorOutMessage)res).getWrappedConnectorOutMessage();
  1065.             }
  1066.         }
  1067.         if(vm!=null){
  1068.             if(context!=null && context.getPddContext()!=null){
  1069.                 DirectVMProtocolInfo pInfo = new DirectVMProtocolInfo();
  1070.                 Object oIdTransazione = context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  1071.                 if(oIdTransazione!=null){
  1072.                     pInfo.setIdTransazione((String)oIdTransazione);
  1073.                 }
  1074.                 if(context.getProtocol()!=null){
  1075.                     if(context.getProtocol().getIdRichiesta()!=null){
  1076.                         pInfo.setIdMessaggioRichiesta(context.getProtocol().getIdRichiesta());
  1077.                     }
  1078.                     if(context.getProtocol().getIdRisposta()!=null){
  1079.                         pInfo.setIdMessaggioRisposta(context.getProtocol().getIdRisposta());
  1080.                     }
  1081.                 }
  1082.                 vm.setDirectVMProtocolInfo(pInfo);
  1083.             }
  1084.         }
  1085.         
  1086.         InformazioniErroriInfrastrutturali informazioniErrori = ServicesUtils.readInformazioniErroriInfrastrutturali(pddContext);
  1087.         
  1088.         EsitoTransazione esito = null;
  1089.         String descrizioneSoapFault = "";
  1090.         int statoServletResponse = 200;
  1091.         Throwable erroreConsegnaRisposta = null; 
  1092.         boolean httpEmptyResponse = false;
  1093.         long lengthOutResponse = -1;
  1094.         boolean erroreConnessioneClient = false;
  1095.         boolean sendInvoked = false;
  1096.         boolean registraTracciaOutResponse = false;
  1097.         try{
  1098.             if(responseMessage!=null && !responseMessage.isForcedEmptyResponse() && (responseMessage.getForcedResponse()==null)){
  1099.                     
  1100.                 // force response code
  1101.                 boolean forced = false;
  1102.                 if(responseMessage.getForcedResponseCode()!=null){
  1103.                     try{
  1104.                         statoServletResponse = Integer.parseInt(responseMessage.getForcedResponseCode());
  1105.                         forced = true;
  1106.                     }catch(Exception e){}
  1107.                 }
  1108.                 
  1109.                 if(ServiceBinding.SOAP.equals(responseMessage.getServiceBinding())) {
  1110.                                         
  1111.                     SOAPBody body = responseMessage.castAsSoap().getSOAPBody();
  1112.                     String contentTypeRisposta = null;
  1113.                     byte[] risposta = null;
  1114.                     if(body!=null && body.hasFault()){
  1115.                         statoServletResponse = 500; // cmq e' un errore come l'errore applicativo
  1116.                         String msgError = SoapUtils.safe_toString(responseMessage.getFactory(), body.getFault(), false, logCore);
  1117.                         //risposta=msgError.getBytes();
  1118.                         org.openspcoop2.message.xml.MessageXMLUtils xmlUtils = org.openspcoop2.message.xml.MessageXMLUtils.getInstance(responseMessage.getFactory());
  1119.                         risposta=xmlUtils.toByteArray(body.getFault(), true);
  1120.                         //System.out.println("ELABORATO:"+new String(risposta));
  1121.                         contentTypeRisposta = responseMessage.getContentType();
  1122.                         descrizioneSoapFault = " ("+msgError+")";   
  1123.                     }else{
  1124.                         risposta=TunnelSoapUtils.sbustamentoMessaggio(responseMessage);
  1125.                         if(risposta==null || risposta.length<=0){
  1126.                             // Si puo' entrare in questo caso, se nel messaggio Soap vi era presente solo l'header
  1127.                             risposta = null;
  1128.                             if(!forced)
  1129.                                 statoServletResponse = 202;
  1130.                         }else{
  1131.                             
  1132.                             SOAPElement child = SoapUtils.getNotEmptyFirstChildSOAPElement(body);
  1133.                             if(child!=null){
  1134.                                 if(protocolFactory.createErroreApplicativoBuilder().isErroreApplicativo(child)){
  1135.                                     statoServletResponse = 500;
  1136.                                 }
  1137.                             }
  1138.                             
  1139.                             // Non serve la updateContentType. Il messaggio e' gia' stato serializzato ed il cType e' corretto.  
  1140.                             if(TunnelSoapUtils.isTunnelOpenSPCoopSoap(responseMessage.getFactory(), body)){
  1141.                                 contentTypeRisposta = TunnelSoapUtils.getContentTypeTunnelOpenSPCoopSoap(body);
  1142.                             }else{
  1143.                                 contentTypeRisposta = responseMessage.getContentType();
  1144.                             }
  1145.                         }
  1146.                     }
  1147.                     
  1148.                     // transfer length
  1149.                     if(risposta!=null){
  1150.                         lengthOutResponse = risposta.length;
  1151.                         ServicesUtils.setTransferLength(openSPCoopProperties.getTransferLengthModes_ricezioneContenutiApplicativi(), 
  1152.                                 req, res, Long.valueOf(risposta.length));
  1153.                     }
  1154.                     
  1155.                     // httpstatus
  1156.                     res.setStatus(statoServletResponse);
  1157.                     
  1158.                     // content type
  1159.                     if(contentTypeRisposta!=null){
  1160.                         res.setContentType(contentTypeRisposta);
  1161.                     }
  1162.                     
  1163.                     // esito calcolato prima del sendResponse, per non consumare il messaggio
  1164.                     esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(), 
  1165.                             statoServletResponse, requestInfo.getIntegrationServiceBinding(),
  1166.                             responseMessage, context.getProprietaErroreAppl(),informazioniErrori,
  1167.                             pddContext);
  1168.                     
  1169.                     // httpHeaders
  1170.                     res.sendResponseHeaders(responseMessage);                   
  1171.                     
  1172.                     // se il tracciamento lo prevedo emetto un log
  1173.                     registraTracciaOutResponse = true;
  1174.                     transazioneDaAggiornare = registraTracciaOutResponse(context, protocolFactory, postOutResponseContext,
  1175.                             dataAccettazioneRichiesta, dataIngressoRichiesta,
  1176.                             dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1177.                             esito, statoServletResponse,
  1178.                             idModulo, req,  requestMessage, inputBody,
  1179.                             responseMessage, erroreConsegnaRisposta, lengthOutResponse,
  1180.                             msgDiag);
  1181.                     
  1182.                     // contenuto
  1183.                     if(risposta!=null){
  1184.                         sendInvoked = true;
  1185.                         res.sendResponse(DumpByteArrayOutputStream.newInstance(risposta));
  1186.                     }
  1187.                 }
  1188.                 else {
  1189.                     
  1190.                     // transfer length
  1191.                     ServicesUtils.setTransferLength(openSPCoopProperties.getTransferLengthModes_ricezioneContenutiApplicativi(), 
  1192.                             req, res, responseMessage);
  1193.                     
  1194.                     // content type
  1195.                     // Alcune implementazioni richiedono di aggiornare il Content-Type
  1196.                     responseMessage.updateContentType();
  1197.                     ServicesUtils.setContentType(responseMessage, res);
  1198.                     
  1199.                     // http status
  1200.                     boolean consume = true;
  1201.                     if(responseMessage.castAsRest().isProblemDetailsForHttpApis_RFC7807() || 
  1202.                             (MessageRole.FAULT.equals(responseMessage.getMessageRole()) &&
  1203.                                 (
  1204.                                 MessageType.XML.equals(responseMessage.getMessageType()) 
  1205.                                         || 
  1206.                                 MessageType.JSON.equals(responseMessage.getMessageType())
  1207.                                 )
  1208.                             )
  1209.                         ) {
  1210.                         consume = false; // può essere usato nel post out response handler
  1211.                         String contentAsString = null;
  1212.                         try {
  1213.                             contentAsString = responseMessage.castAsRest().getContentAsString();
  1214.                         }catch(Throwable t) {
  1215.                             logCore.error("Parsing errore non riuscito: "+t.getMessage(),t);
  1216.                         }
  1217.                         if(contentAsString!=null && StringUtils.isNotEmpty(contentAsString)) {
  1218.                             descrizioneSoapFault = " ("+contentAsString+")";
  1219.                         }
  1220.                     }
  1221.                     res.setStatus(statoServletResponse);
  1222.                     
  1223.                     // esito calcolato prima del sendResponse, per non consumare il messaggio
  1224.                     esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(), 
  1225.                             statoServletResponse, requestInfo.getIntegrationServiceBinding(),
  1226.                             responseMessage, context.getProprietaErroreAppl(), informazioniErrori,
  1227.                             pddContext);
  1228.                     
  1229.                     // se il tracciamento lo prevedo emetto un log
  1230.                     registraTracciaOutResponse = true;
  1231.                     transazioneDaAggiornare = registraTracciaOutResponse(context, protocolFactory, postOutResponseContext,
  1232.                             dataAccettazioneRichiesta, dataIngressoRichiesta,
  1233.                             dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1234.                             esito, statoServletResponse,
  1235.                             idModulo, req,  requestMessage, inputBody,
  1236.                             responseMessage, erroreConsegnaRisposta, lengthOutResponse,
  1237.                             msgDiag);
  1238.                     
  1239.                     // contenuto
  1240.                     Utilities.printFreeMemory("RicezioneContenutiApplicativiDirect - Pre scrittura risposta");
  1241.                     
  1242.                     // Il contentLenght, nel caso di TransferLengthModes.CONTENT_LENGTH e' gia' stato calcolato
  1243.                     // con una writeTo senza consume. Riuso il solito metodo per evitare differenze di serializzazione
  1244.                     // e cambiare quindi il content length effettivo.
  1245.                     sendInvoked = true;
  1246.                     if(TransferLengthModes.CONTENT_LENGTH.equals(openSPCoopProperties.getTransferLengthModes_ricezioneContenutiApplicativi())){
  1247.                         res.sendResponse(responseMessage, false);
  1248.                     } else {
  1249.                         res.sendResponse(responseMessage, consume);
  1250.                     }
  1251.                     Utilities.printFreeMemory("RicezioneContenutiApplicativiDirect - Post scrittura risposta");
  1252.                     
  1253.                 }
  1254.                 
  1255.             }
  1256.             else if(responseMessage!=null && responseMessage.getForcedResponse()!=null) {
  1257.                 byte[]response = responseMessage.getForcedResponse().getContent();
  1258. //              if(response==null) {
  1259. //                  throw new Exception("Trovata configurazione 'forcedResponse' senza una vera risposta");
  1260. //              }
  1261.                 if(response!=null) {
  1262.                     lengthOutResponse = response.length;
  1263.                 }
  1264.             
  1265.                 if(response!=null && response.length<1024) {
  1266.                     // Se il messaggio non è troppo grande lo aggiungo al diagnostico
  1267.                     try {
  1268.                         descrizioneSoapFault = "("+new String(response)+")";
  1269.                     }catch(Throwable t) {
  1270.                         descrizioneSoapFault = "";
  1271.                     }
  1272.                 }
  1273.                 
  1274.                 if(responseMessage.getForcedResponse().getHeadersValues()!=null &&
  1275.                         responseMessage.getForcedResponse().getHeadersValues().size()>0) {
  1276.                     Iterator<String> keys = responseMessage.getForcedResponse().getHeadersValues().keySet().iterator();
  1277.                     while (keys.hasNext()) {
  1278.                         String key = (String) keys.next();
  1279.                         List<String> values = responseMessage.getForcedResponse().getHeadersValues().get(key);
  1280.                         if(values!=null && !values.isEmpty()) {
  1281.                             for (int i = 0; i < values.size(); i++) {
  1282.                                 String value = values.get(i);
  1283.                                 String verbo = "";
  1284.                                 try{
  1285.                                     if(i==0) {
  1286.                                         verbo = "set";
  1287.                                         res.setHeader(key,value);
  1288.                                     }
  1289.                                     else {
  1290.                                         verbo = "add";
  1291.                                         res.addHeader(key,value);
  1292.                                     }
  1293.                                 }catch(Exception e){
  1294.                                     logCore.error("Response(Forced)."+verbo+"Header("+key+","+value+") error: "+e.getMessage(),e);
  1295.                                 }   
  1296.                             }
  1297.                         }
  1298.                     }   
  1299.                 }
  1300.                 
  1301.                 if(responseMessage.getForcedResponse().getContentType()!=null) {
  1302.                     res.setContentType(responseMessage.getForcedResponse().getContentType());
  1303.                 }
  1304.                 
  1305.                 if(responseMessage.getForcedResponse().getResponseCode()!=null) {
  1306.                     try{
  1307.                         statoServletResponse = Integer.parseInt(responseMessage.getForcedResponse().getResponseCode());
  1308.                     }catch(Exception e){}
  1309.                 }
  1310.                 else if(responseMessage!=null && responseMessage.getForcedResponseCode()!=null) {
  1311.                     try{
  1312.                         statoServletResponse = Integer.parseInt(responseMessage.getForcedResponseCode());
  1313.                     }catch(Exception e){}
  1314.                 }
  1315.                 res.setStatus(statoServletResponse);
  1316.                 
  1317.                 // esito calcolato prima del sendResponse, per non consumare il messaggio
  1318.                 esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(), 
  1319.                         statoServletResponse, requestInfo.getIntegrationServiceBinding(),
  1320.                         responseMessage, context.getProprietaErroreAppl(),informazioniErrori,
  1321.                         pddContext);
  1322.                 
  1323.                 // se il tracciamento lo prevedo emetto un log
  1324.                 registraTracciaOutResponse = true;
  1325.                 transazioneDaAggiornare = registraTracciaOutResponse(context, protocolFactory, postOutResponseContext,
  1326.                         dataAccettazioneRichiesta, dataIngressoRichiesta,
  1327.                         dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1328.                         esito, statoServletResponse,
  1329.                         idModulo, req,  requestMessage, inputBody,
  1330.                         responseMessage, erroreConsegnaRisposta, lengthOutResponse,
  1331.                         msgDiag);
  1332.                 
  1333.                 if(response!=null) {
  1334.                     sendInvoked = true;
  1335.                     res.sendResponse(DumpByteArrayOutputStream.newInstance(response));
  1336.                 }
  1337.                 
  1338.             }           
  1339.             else{
  1340.                 // httpstatus
  1341.                 if(responseMessage!=null && responseMessage.getForcedResponseCode()!=null) {
  1342.                     try{
  1343.                         statoServletResponse = Integer.parseInt(responseMessage.getForcedResponseCode());
  1344.                     }catch(Exception e){}
  1345.                 }
  1346.                 else {
  1347.                     statoServletResponse = protocolFactory.createProtocolManager().getHttpReturnCodeEmptyResponseOneWay();
  1348.                 }
  1349.                 res.setStatus(statoServletResponse);
  1350.                 httpEmptyResponse = true;
  1351.                 esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(), 
  1352.                         statoServletResponse, requestInfo.getIntegrationServiceBinding(),
  1353.                         responseMessage, context.getProprietaErroreAppl(),informazioniErrori,
  1354.                         pddContext);
  1355.                 // carico-vuoto
  1356.                 
  1357.                 // se il tracciamento lo prevedo emetto un log
  1358.                 registraTracciaOutResponse = true;
  1359.                 transazioneDaAggiornare = registraTracciaOutResponse(context, protocolFactory, postOutResponseContext,
  1360.                         dataAccettazioneRichiesta, dataIngressoRichiesta,
  1361.                         dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1362.                         esito, statoServletResponse,
  1363.                         idModulo, req,  requestMessage, inputBody,
  1364.                         responseMessage, erroreConsegnaRisposta, lengthOutResponse,
  1365.                         msgDiag);

  1367.             }
  1368.             
  1369.         }catch(Throwable e){
  1370.             logCore.error("ErroreGenerale",e);
  1371.             erroreConsegnaRisposta = e;
  1372.             
  1373.             erroreConnessioneClient = ServicesUtils.isConnessioneClientNonDisponibile(e);
  1374.             
  1375.             try{
  1376.                 esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(),EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX);
  1377.             }catch(Exception eBuildError){
  1378.                 esito = EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  1379.             }
  1380.             
  1381.             // Genero risposta con errore
  1382.             try{
  1383.                 if(sendInvoked==false) {
  1384.                     // nel caso sia già stato inoltrata una risposta non e' più possibile modificarlo cosi come tutti gli header etc... 
  1385.                     byte [] rispostaErrore = null;
  1386.                     List<Integer> returnCode = new ArrayList<Integer>();
  1387.                     InformazioniErroriInfrastrutturali informazioniErrori_error = null;
  1388.                     if( (responseMessage!=null && responseMessage.getParseException() != null) ||
  1389.                             (pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION))){
  1390.                         ParseException parseException = null;
  1391.                         if( responseMessage!=null && responseMessage.getParseException() != null ){
  1392.                             parseException = responseMessage.getParseException();
  1393.                         }
  1394.                         else{
  1395.                             parseException = (ParseException) pddContext.getObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  1396.                         }
  1397.                         String msgErrore = parseException.getParseException().getMessage();
  1398.                         if(msgErrore==null){
  1399.                             msgErrore = parseException.getParseException().toString();
  1400.                         }
  1401.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  1402.                         logCore.error("parsingExceptionRisposta",parseException.getSourceException());
  1403.                         msgDiag.logPersonalizzato("parsingExceptionRisposta");
  1404.                                             
  1405.                         rispostaErrore = this.generatoreErrore.buildAsByteArray(pddContext, IntegrationFunctionError.UNPROCESSABLE_RESPONSE_CONTENT,
  1406.                                 ErroriIntegrazione.ERRORE_440_PARSING_EXCEPTION_RISPOSTA.
  1407.                                 getErrore440_MessaggioRispostaMalformato(parseException.getParseException()),
  1408.                                 returnCode);
  1409.                         
  1410.                         informazioniErrori_error = new InformazioniErroriInfrastrutturali();
  1411.                         informazioniErrori_error.setContenutoRispostaNonRiconosciuto(true);
  1412.                     } 
  1413.                     else{
  1414.                         IntegrationFunctionError ife = IntegrationFunctionError.INTERNAL_RESPONSE_ERROR;
  1415.                         if(e instanceof HandlerException) {
  1416.                             HandlerException he = (HandlerException) e;
  1417.                             if(he.getIntegrationFunctionError()!=null) {
  1418.                                 ife = he.getIntegrationFunctionError();
  1419.                             }
  1420.                         }
  1421.                         rispostaErrore = this.generatoreErrore.buildAsByteArray(pddContext, ife,
  1422.                                 ErroriIntegrazione.ERRORE_426_SERVLET_ERROR.
  1423.                                 getErrore426_ServletError(false, e),
  1424.                                 returnCode);
  1425.                     }
  1426.                     
  1427.                     // transfer length
  1428.                     lengthOutResponse = rispostaErrore.length;
  1429.                     ServicesUtils.setTransferLength(openSPCoopProperties.getTransferLengthModes_ricezioneContenutiApplicativi(), 
  1430.                             req, res, Long.valueOf(rispostaErrore.length));
  1431.                     
  1432.                     // httpstatus
  1433.                     //statoServletResponse = 500; // Nella servlet con sbustamento non devo ritornare 500
  1434.                     statoServletResponse = 200;
  1435.                     if(returnCode!=null && returnCode.size()>0){
  1436.                         statoServletResponse = returnCode.get(0);
  1437.                     }
  1438.                     res.setStatus(statoServletResponse);
  1439.                     
  1440.                     // esito calcolato prima del sendResponse, per non consumare il messaggio
  1441.                     if(informazioniErrori_error!=null) {
  1442.                         esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(),
  1443.                                 statoServletResponse, requestInfo.getIntegrationServiceBinding(),
  1444.                                 null, context.getProprietaErroreAppl(), informazioniErrori_error,
  1445.                                 pddContext);
  1446.                     }
  1447.                     
  1448.                     // content type
  1449.                     res.setContentType("text/xml");
  1450.                     
  1451.                     // se il tracciamento lo prevedo emetto un log
  1452.                     // se ho già provato prima a tracciare non lo faccio un'altra volta
  1453.                     if(!registraTracciaOutResponse) {
  1454.                         transazioneDaAggiornare = registraTracciaOutResponse(context, protocolFactory, postOutResponseContext,
  1455.                             dataAccettazioneRichiesta, dataIngressoRichiesta,
  1456.                             dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1457.                             esito, statoServletResponse,
  1458.                             idModulo, req,  requestMessage, inputBody,
  1459.                             responseMessage, erroreConsegnaRisposta, lengthOutResponse,
  1460.                             msgDiag);
  1461.                     }
  1462.                     
  1463.                     // contenuto
  1464.                     res.sendResponse(DumpByteArrayOutputStream.newInstance(rispostaErrore));
  1465.                 }
  1466.                         
  1467.             }catch(Throwable error){
  1468.                 
  1469.                 if(!erroreConnessioneClient){
  1470.                     erroreConnessioneClient = ServicesUtils.isConnessioneClientNonDisponibile(error);
  1471.                 }
  1472.                 
  1473.                 logCore.error("Generazione di un risposta errore non riuscita",error);
  1474.                 statoServletResponse = 500; // ERRORE EFFETTIVO!
  1475.                 try{
  1476.                     res.setStatus(500);
  1477.                 }catch(Exception eStatus){
  1478.                     logCore.error("Response.setStatus(500) error: "+eStatus.getMessage(),eStatus);
  1479.                 }
  1480.                 byte[] ris = error.toString().getBytes();
  1481.                 try{
  1482.                     res.sendResponse(DumpByteArrayOutputStream.newInstance(ris));
  1483.                 }catch(Exception erroreStreamChiuso){ 
  1484.                     erroreConnessioneClient = true;
  1485.                     //se lo stream non e' piu' disponibile non si potra' consegnare alcuna risposta
  1486.                 }
  1487.                 lengthOutResponse = ris.length;
  1488.             }
  1489.             
  1490.         }
  1491.         finally{
  1492.             if(sendInvoked==false) {
  1493.                 // nel caso sia già stato inoltrata una risposta non e' più possibile modificarlo cosi come tutti gli header etc...         
  1494.                 statoServletResponse = res.getResponseStatus(); // puo' essere "trasformato" da api engine
  1495.             }
  1496.             msgDiag.addKeyword(CostantiPdD.KEY_CODICE_CONSEGNA, ""+statoServletResponse);
  1497.             msgDiag.addKeyword(CostantiPdD.KEY_SOAP_FAULT, descrizioneSoapFault);
  1498.             
  1499.             try{
  1500.                 
  1501.                 // Flush and close response
  1502.                 // NOTA: per poter ottenere l'errore di BrokenPipe sempre, deve essere disabilitato il socketBufferOutput sul servlet container.
  1503.                 // Se non lo si disabilta, l'errore viene ritornato solo se il messaggio supera la dimensione del buffer (default: 8192K)
  1504.                 // Ad esempio in tomcat utilizzare (socketBuffer="-1"): 
  1505.                 //    <Connector protocol="HTTP/1.1" port="8080" address="${jboss.bind.address}" 
  1506.                 //       connectionTimeout="20000" redirectPort="8443" socketBuffer="-1" />
  1507.                 res.flush(true);
  1508.                 res.close(true);
  1509.                 
  1510.                 dataRispostaSpedita = DateManager.getDate();
  1511.                 
  1512.                 // Emetto diagnostico
  1513.                 if(erroreConsegnaRisposta!=null){
  1514.                     
  1515.                     // Risposta non ritornata al servizio applicativo, il socket verso il servizio applicativo era chiuso o cmq inutilizzabile
  1516.                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_CONSEGNA, erroreConsegnaRisposta.toString()); // NOTA: lasciare e.toString()
  1517.                     msgDiag.logPersonalizzato("consegnaRispostaApplicativaFallita");
  1518.                     
  1519.                 }else{
  1520.                     if(httpEmptyResponse){
  1521.                         msgDiag.logPersonalizzato("consegnaRispostaApplicativaVuota");
  1522.                     }else{
  1523.                         if(statoServletResponse>=300)
  1524.                             msgDiag.logPersonalizzato("consegnaRispostaApplicativaKoEffettuata");
  1525.                         else
  1526.                             msgDiag.logPersonalizzato("consegnaRispostaApplicativaOkEffettuata");
  1527.                     }
  1528.                 }
  1529.                 
  1530.             }catch(Exception e){
  1531.                 
  1532.                 erroreConnessioneClient = true;
  1533.                 
  1534.                 logCore.error("Chiusura stream non riuscita",e);
  1535.                 
  1536.                 // Risposta non ritornata al servizio applicativo, il socket verso il servizio applicativo era chiuso o cmq inutilizzabile
  1537.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_CONSEGNA, e.toString()); // NOTA: lasciare e.toString()
  1538.                 
  1539.                 msgDiag.logPersonalizzato("consegnaRispostaApplicativaFallita");
  1540.                 
  1541.                 erroreConsegnaRisposta = e;
  1542.                 
  1543.                 if(esito!=null){
  1544.                     if(EsitoTransazioneName.OK.equals(esito.getName())){
  1545.                         // non è ok, essendo andato in errore il flush
  1546.                         try{
  1547.                             esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(),EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX);
  1548.                         }catch(Exception eBuildError){
  1549.                             esito = EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  1550.                         }
  1551.                     }
  1552.                 }
  1553.                 else{
  1554.                     // non dovrebbe mai essere null
  1555.                 }
  1556.                 
  1557.             } finally {
  1558.                 if(dataRispostaSpedita==null) {
  1559.                     dataRispostaSpedita = DateManager.getDate();
  1560.                 }
  1561.             }
  1562.             
  1563.             if(dumpRaw!=null && dumpRaw.isActiveDumpRisposta()){
  1564.                 dumpRaw.serializeResponse(((DumpRawConnectorOutMessage)res));
  1565.             }
  1566.             
  1567.         }
  1568.         
  1569.         if(erroreConnessioneClient){
  1570.             // forzo esito errore connessione client
  1571.             try{
  1572.                 esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(),EsitoTransazioneName.ERRORE_CONNESSIONE_CLIENT_NON_DISPONIBILE);
  1573.             }catch(Exception eBuildError){
  1574.                 esito = EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  1575.             }
  1576.         }
  1577.         else if(EsitoTransazioneName.OK.equals(esito.getName()) && context!=null && context.getPddContext()!=null && context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.EMESSI_DIAGNOSTICI_ERRORE)) {
  1578.             // caso di errore generato durante il tracciamento dopo aver calcolato l'esito, in cui non viene sollevata una eccezione
  1579.             esito = ServicesUtils.updateEsitoConAnomalie(esito, logCore, protocolFactory);
  1580.         }
  1581.         
  1582.         
  1583.         
  1584.         
  1585.         
  1586.         
  1587.         
  1588.         // *** Chiudo connessione verso PdD Destinazione per casi stateless ***
  1589.         String location = "...";
  1590.         try{
  1591.             IConnettore c = null;
  1592.             if(context!=null && context.getPddContext()!=null && context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) {
  1593.                 idTransazione = (String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  1594.             }
  1595.             if(idTransazione!=null) {
  1596.             //if(context.getIdMessage()!=null){
  1597.                 c = RepositoryConnettori.removeConnettorePD(
  1598.                         //context.getIdMessage()
  1599.                         idTransazione
  1600.                         );
  1601.             }
  1602.             if(c!=null){
  1603.                 location = c.getLocation();
  1604.                 c.disconnect();
  1605.             }
  1606.         }catch(Exception e){
  1607.             msgDiag.logDisconnectError(e, location);
  1608.         }
  1609.         
  1610.         

  1612.         
  1613.         
  1614.         
  1615.         
  1616.         
  1617.         
  1618.         
  1619.         /* ------------  PostOutResponseHandler ------------- */
  1620.         
  1621.         if(postOutResponseContext!=null){
  1622.             try {
  1623.                 updateContext(context, protocolFactory, postOutResponseContext,
  1624.                         dataAccettazioneRichiesta, dataIngressoRichiesta,
  1625.                         dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1626.                         esito, statoServletResponse,
  1627.                         idModulo, req,  requestMessage, inputBody,
  1628.                         responseMessage, erroreConsegnaRisposta, lengthOutResponse);
  1629.                 postOutResponseContext.setTransazioneDaAggiornare(transazioneDaAggiornare);
  1630.             }catch(Exception e){
  1631.                 msgDiag.logErroreGenerico(e,"postOutResponse, preparazione contesto");
  1632.             }
  1633.             
  1634.             GestoreHandlers.postOutResponse(postOutResponseContext, msgDiag, logCore);
  1635.         }
  1636.         
  1637.         
  1638.         
  1639.         
  1640.         
  1641.         
  1642.         
  1643.         
  1644.         
  1645.         
  1646.         // *** Rilascio risorse NotifierInputStream ***
  1647.         
  1648.         // request
  1649.         try{
  1650.             if(requestMessage!=null && requestMessage.getNotifierInputStream()!=null){
  1651.                 requestMessage.getNotifierInputStream().close();
  1652.             }
  1653.         }catch(Exception e){
  1654.             msgDiag.logErroreGenerico(e,"Rilascio risorse NotifierInputStream richiesta");
  1655.         }
  1656.         
  1657.         // response
  1658.         try{
  1659.             if(responseMessage!=null && responseMessage.getNotifierInputStream()!=null){
  1660.                 responseMessage.getNotifierInputStream().close();
  1661.             }
  1662.         }catch(Exception e){
  1663.             msgDiag.logErroreGenerico(e,"Rilascio risorse NotifierInputStream risposta");
  1664.         }
  1665.         
  1666.         
  1667.         
  1668.         
  1669.         
  1670.         
  1671.         
  1672.         
  1673.         
  1674.         // *** GB ***
  1675.         requestMessage = null;
  1676.         responseMessage = null;
  1677.         // *** GB ***
  1678.         
  1679.         return;

  1681.     }


  1684.     private void updateContext(RicezioneContenutiApplicativiContext context, IProtocolFactory<?> protocolFactory, PostOutResponseContext postOutResponseContext,
  1685.             Date dataAccettazioneRichiesta, Date dataIngressoRichiesta,
  1686.             Date dataPrimaSpedizioneRisposta, Date dataRispostaSpedita,
  1687.             EsitoTransazione esito, int statoServletResponse,
  1688.             String idModulo, ConnectorInMessage req, OpenSPCoop2Message requestMessage, byte[] inputBody,
  1689.             OpenSPCoop2Message responseMessage, Throwable erroreConsegnaRisposta, long lengthOutResponse) throws ConnectorException {
  1690.         if(postOutResponseContext!=null){
  1691.             postOutResponseContext.getPddContext().addObject(CostantiPdD.DATA_ACCETTAZIONE_RICHIESTA, dataAccettazioneRichiesta);
  1692.             if(dataIngressoRichiesta!=null){
  1693.                 postOutResponseContext.getPddContext().addObject(CostantiPdD.DATA_INGRESSO_RICHIESTA, dataIngressoRichiesta);
  1694.             }
  1695.             postOutResponseContext.setDataElaborazioneMessaggio(DateManager.getDate());
  1696.             postOutResponseContext.setDataPrimaSpedizioneRisposta(dataPrimaSpedizioneRisposta);
  1697.             postOutResponseContext.setDataRispostaSpedita(dataRispostaSpedita);
  1698.             if(erroreConsegnaRisposta==null){
  1699.                 postOutResponseContext.setEsito(esito);
  1700.             }else{
  1701.                 try{
  1702.                     esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(),EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX);
  1703.                 }catch(Exception eBuildError){
  1704.                     esito = EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  1705.                 }
  1706.                 postOutResponseContext.setEsito(esito);
  1707.             }
  1708.             postOutResponseContext.setReturnCode(statoServletResponse);
  1709.             postOutResponseContext.setResponseHeaders(context.getResponseHeaders());
  1710.             postOutResponseContext.setProtocollo(context.getProtocol());
  1711.             postOutResponseContext.setIntegrazione(context.getIntegrazione());
  1712.             if(context.getTipoPorta()!=null)
  1713.                 postOutResponseContext.setTipoPorta(context.getTipoPorta());    
  1714.             postOutResponseContext.setIdModulo(idModulo);
  1715.             
  1716.             if(inputBody!=null){
  1717.                 postOutResponseContext.setInputRequestMessageSize(Long.valueOf(inputBody.length));
  1718.             }
  1719.             if(requestMessage!=null){
  1720.                 /**postOutResponseContext.setInputRequestMessageSize(requestMessage.getIncomingMessageContentLength());*/
  1721.                 postOutResponseContext.setOutputRequestMessageSize(requestMessage.getOutgoingMessageContentLength());
  1722.             }else{
  1723.                 postOutResponseContext.setInputRequestMessageSize(req.getContentLength()+0l);
  1724.             }
  1725.             
  1726.             if(erroreConsegnaRisposta==null && responseMessage!=null  && !responseMessage.isForcedEmptyResponse() && responseMessage.getForcedResponse()==null){
  1727.                 postOutResponseContext.setInputResponseMessageSize(responseMessage.getIncomingMessageContentLength());
  1728.                 postOutResponseContext.setOutputResponseMessageSize(lengthOutResponse); // sbustata!
  1729.                 postOutResponseContext.setMessaggio(responseMessage);
  1730.             }
  1731.             else if(responseMessage!=null && responseMessage.getForcedResponse()!=null &&
  1732.                     responseMessage.getForcedResponse().getContent()!=null) {
  1733.                 postOutResponseContext.setInputResponseMessageSize(responseMessage.getIncomingMessageContentLength());
  1734.                 postOutResponseContext.setOutputResponseMessageSize((long) responseMessage.getForcedResponse().getContent().length);
  1735.             }   
  1736.         }       
  1737.     }

  1739.     private Transazione registraTracciaOutResponse(RicezioneContenutiApplicativiContext context, 
  1740.             IProtocolFactory<?> protocolFactory, 
  1741.             PostOutResponseContext postOutResponseContext,
  1742.             Date dataAccettazioneRichiesta, Date dataIngressoRichiesta,
  1743.             Date dataPrimaSpedizioneRisposta, Date dataRispostaSpedita,
  1744.             EsitoTransazione esito, int statoServletResponse,
  1745.             String idModulo, ConnectorInMessage req, OpenSPCoop2Message requestMessage, byte[] inputBody,
  1746.             OpenSPCoop2Message responseMessage, Throwable erroreConsegnaRisposta, long lengthOutResponse,
  1747.             MsgDiagnostico msgDiag) throws HandlerException {

  1749.         try {
  1750.         
  1751.             if(postOutResponseContext!=null) {
  1752.                 updateContext(context, protocolFactory, postOutResponseContext,
  1753.                         dataAccettazioneRichiesta, dataIngressoRichiesta,
  1754.                         dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1755.                         esito, statoServletResponse,
  1756.                         idModulo, req,  requestMessage, inputBody,
  1757.                         responseMessage, erroreConsegnaRisposta, lengthOutResponse);
  1758.                 
  1759.                 TracciamentoManager tracciamentoManager = new TracciamentoManager(FaseTracciamento.OUT_RESPONSE);
  1760.                 if(!tracciamentoManager.isTransazioniEnabled()) {
  1761.                     return null;
  1762.                 }
  1763.                 
  1764.                 InformazioniTransazione info = new InformazioniTransazione(postOutResponseContext);
  1765.                 
  1766.                 tracciamentoManager.invoke(info, postOutResponseContext.getEsito(), context.getResponseHeaders(), msgDiag);
  1767.                 
  1768.                 return info.getTransazioneDaAggiornare();
  1769.             }

  1771.         }catch(Exception e) {
  1772.             ServicesUtils.processTrackingException(e, postOutResponseContext.getLogCore(), FaseTracciamento.OUT_RESPONSE, context.getPddContext());
  1773.         }
  1774.         
  1775.         return null;
  1776.     }
  1777.     
  1778.     private void registraTracciaInRequest(RicezioneContenutiApplicativiContext context,
  1779.             IProtocolFactory<?> protocolFactory, Logger log, 
  1780.             MsgDiagnostico msgDiag) throws HandlerException{
  1781.         
  1782.         try {
  1783.         
  1784.             TracciamentoManager tracciamentoManager = new TracciamentoManager(FaseTracciamento.IN_REQUEST);
  1785.             if(!tracciamentoManager.isTransazioniEnabled()) {
  1786.                 return;
  1787.             }
  1788.                 
  1789.             InformazioniTransazione info = new InformazioniTransazione();
  1790.             info.setContext(context.getPddContext());
  1791.             info.setTipoPorta(context.getTipoPorta());
  1792.             info.setProtocolFactory(protocolFactory);
  1793.             info.setProtocollo(context.getProtocol());
  1794.             info.setIntegrazione(context.getIntegrazione());
  1795.             info.setIdModulo(context.getIdModulo());
  1796.             
  1797.             TransportRequestContext transportRequestContext = null;
  1798.             if(context.getMessageRequest()!=null) {
  1799.                 transportRequestContext = context.getMessageRequest().getTransportRequestContext();
  1800.             }
  1801.             String esitoContext = EsitoBuilder.getTipoContext(transportRequestContext, EsitiProperties.getInstance(log, protocolFactory), log);
  1802.             
  1803.             tracciamentoManager.invoke(info, esitoContext, msgDiag);
  1804.             
  1805.         }catch(Exception e) {
  1806.             ServicesUtils.processTrackingException(e, log, FaseTracciamento.IN_REQUEST, context.getPddContext());
  1807.         }
  1808.         
  1809.     }
  1810. }
Created with JaCoCo 0.8.8.202204050719