RicezioneContenutiApplicativiService.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.Date;
  26. import java.util.HashMap;
  27. import java.util.Iterator;
  28. import java.util.List;
  29. import java.util.Map;

  31. import javax.xml.soap.SOAPBody;

  33. import org.apache.commons.io.output.NullOutputStream;
  34. import org.apache.commons.lang.StringUtils;
  35. import org.openspcoop2.core.commons.CoreException;
  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.OpenSPCoop2SoapMessage;
  47. import org.openspcoop2.message.constants.MessageRole;
  48. import org.openspcoop2.message.constants.MessageType;
  49. import org.openspcoop2.message.constants.ServiceBinding;
  50. import org.openspcoop2.message.exception.ParseException;
  51. import org.openspcoop2.message.exception.ParseExceptionUtils;
  52. import org.openspcoop2.message.soap.SoapUtils;
  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.RicezioneContenutiApplicativiConnector;
  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.LimitedInputStream;
  112. import org.openspcoop2.utils.LoggerWrapperFactory;
  113. import org.openspcoop2.utils.TimeoutIOException;
  114. import org.openspcoop2.utils.TimeoutInputStream;
  115. import org.openspcoop2.utils.Utilities;
  116. import org.openspcoop2.utils.date.DateManager;
  117. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  118. import org.openspcoop2.utils.io.notifier.NotifierInputStreamParams;
  119. import org.openspcoop2.utils.transport.TransportRequestContext;
  120. import org.openspcoop2.utils.transport.http.HttpConstants;
  121. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  122. import org.slf4j.Logger;

  124. /**
  125.  * RicezioneContenutiApplicativiService
  126.  *
  127.  * @author Poli Andrea (apoli@link.it)
  128.  * @author Lorenzo Nardi (nardi@link.it)
  129.  * @author $Author$
  130.  * @version $Rev$, $Date$
  131.  */



  135. public class RicezioneContenutiApplicativiService {

  137.     
  138.     private RicezioneContenutiApplicativiInternalErrorGenerator generatoreErrore;
  139.     
  140.     public RicezioneContenutiApplicativiService(RicezioneContenutiApplicativiInternalErrorGenerator generatoreErrore){
  141.         this.generatoreErrore = generatoreErrore;
  142.     }
  143.     

  145.     public void process(ConnectorInMessage req, ConnectorOutMessage res, Date dataAccettazioneRichiesta) throws ConnectorException {

  147.         // Timestamp
  148.         Date dataIngressoRichiesta = null;
  149.         
  150.         // IDModulo
  151.         String idModulo = req.getIdModulo();
  152.         IDService idModuloAsService = req.getIdModuloAsIDService();
  153.         RequestInfo requestInfo = req.getRequestInfo();
  154.                 
  155.         // Log
  156.         Logger logCore = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  157.         if(logCore==null)
  158.             logCore = LoggerWrapperFactory.getLogger(idModulo);

  160.         OpenSPCoop2Properties openSPCoopProperties = OpenSPCoop2Properties.getInstance();
  161.         

  163.         /* ------------  PreInHandler (PreInAcceptRequestContext) ------------- */
  164.         
  165.         PreInAcceptRequestContext preInAcceptRequestContext = null;
  166.         if (openSPCoopProperties != null && OpenSPCoop2Startup.initialize) {
  167.         
  168.             // build context
  169.             preInAcceptRequestContext = new PreInAcceptRequestContext();
  170.             preInAcceptRequestContext.setTipoPorta(TipoPdD.DELEGATA);
  171.             preInAcceptRequestContext.setIdModulo(idModulo);
  172.             preInAcceptRequestContext.setRequestInfo(requestInfo);  
  173.             preInAcceptRequestContext.setLogCore(logCore);
  174.             
  175.             // valori che verranno aggiornati dopo
  176.             try {
  177.                 if(openSPCoopProperties.isConnettoriUseLimitedInputStream()) {
  178.                     SogliaDimensioneMessaggio soglia = new SogliaDimensioneMessaggio();
  179.                     soglia.setSogliaKb(openSPCoopProperties.getLimitedInputStreamThresholdKb());
  180.                     soglia.setUseContentLengthHeader(openSPCoopProperties.isLimitedInputStreamUseContentLength());
  181.                     soglia.setUseContentLengthHeaderAcceptZeroValue(openSPCoopProperties.isLimitedInputStreamUseContentLengthAcceptZeroValue());
  182.                     soglia.setPolicyGlobale(true);
  183.                     soglia.setNomePolicy("GovWayCore");
  184.                     soglia.setIdPolicyConGruppo("GovWayCore");
  185.                     req.setRequestLimitedStream(soglia);
  186.                 }
  187.                 if(openSPCoopProperties.isConnettoriUseTimeoutInputStream()) {
  188.                     SogliaReadTimeout soglia = new SogliaReadTimeout();
  189.                     soglia.setSogliaMs(openSPCoopProperties.getReadConnectionTimeout_ricezioneContenutiApplicativi());
  190.                     soglia.setConfigurazioneGlobale(true);
  191.                     soglia.setIdConfigurazione("GovWayCore");
  192.                     req.setRequestReadTimeout(soglia);
  193.                 }
  194.                 req.setThresholdContext(null, 
  195.                     openSPCoopProperties.getDumpBinarioInMemoryThreshold(), openSPCoopProperties.getDumpBinarioRepository());
  196.             }catch(Throwable t) {
  197.                 logCore.error(t.getMessage(),t);
  198.             }
  199.             preInAcceptRequestContext.setReq(req);
  200.             
  201.             // invocazione handler
  202.             GestoreHandlers.preInRequest(preInAcceptRequestContext, logCore, logCore);
  203.             
  204.         }
  205.         
  206.         
  207.         
  208.         // GeneratoreErrore
  209.         try{
  210.             if(this.generatoreErrore==null){
  211.                 this.generatoreErrore = 
  212.                         new RicezioneContenutiApplicativiInternalErrorGenerator(logCore, RicezioneContenutiApplicativiConnector.ID_MODULO, requestInfo);
  213.             }
  214.         }catch(Exception e){
  215.             String msg = "Inizializzazione Generatore Errore fallita: "+Utilities.readFirstErrorValidMessageFromException(e);
  216.             logCore.error(msg,e);
  217.             ConnectorDispatcherErrorInfo cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore, // il metodo doError gestisce il generatoreErrore a null
  218.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  219.                     get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA), 
  220.                     IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, e, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  221.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(logCore, req, null, dataAccettazioneRichiesta, cInfo);
  222.             return;
  223.         }
  224.         
  225.         // Proprieta' OpenSPCoop
  226.         if (!OpenSPCoop2Startup.initialize || openSPCoopProperties == null) {
  227.             String msg = "Inizializzazione di GovWay non correttamente effettuata: OpenSPCoopProperties";
  228.             if(!OpenSPCoop2Startup.initialize) {
  229.                 msg = "Inizializzazione di GovWay non correttamente effettuata";
  230.             }
  231.             logCore.error(msg);
  232.             ConnectorDispatcherErrorInfo cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore, 
  233.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  234.                         get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA), 
  235.                         IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, null, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  236.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(logCore, req, null, dataAccettazioneRichiesta, cInfo);
  237.             return;
  238.         }
  239.                 
  240.         // Configurazione Reader
  241.         ConfigurazionePdDManager configPdDManager = null;
  242.         try{
  243.             configPdDManager = ConfigurazionePdDManager.getInstance();
  244.             if(configPdDManager==null || configPdDManager.isInitializedConfigurazionePdDReader()==false){
  245.                 throw new Exception("ConfigurazionePdDManager not initialized");
  246.             }
  247.         }catch(Throwable e){
  248.             String msg = "Inizializzazione di GovWay non correttamente effettuata: ConfigurazionePdDManager";
  249.             logCore.error(msg);
  250.             ConnectorDispatcherErrorInfo cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore, 
  251.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  252.                         get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA), 
  253.                         IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, e, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  254.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(logCore, req, null, dataAccettazioneRichiesta, cInfo);
  255.             return;
  256.         }
  257.             
  258.         // PddContext from servlet
  259.         Object oPddContextFromServlet = null;
  260.         try{
  261.             oPddContextFromServlet = req.getAttribute(CostantiPdD.OPENSPCOOP2_PDD_CONTEXT_HEADER_HTTP.getValue());
  262.         }catch(Exception e){
  263.             logCore.error("req.getAttribute("+CostantiPdD.OPENSPCOOP2_PDD_CONTEXT_HEADER_HTTP+") error: "+e.getMessage(),e);
  264.         }
  265.         PdDContext pddContextFromServlet = null;
  266.         if(oPddContextFromServlet!=null){
  267.             pddContextFromServlet = (PdDContext) oPddContextFromServlet;
  268.         }
  269.         
  270.         // check requestInfo
  271.         if(requestInfo==null) {
  272.             String msg = "RequestInfo undefined";
  273.             logCore.error(msg);
  274.             return;
  275.         }
  276.         
  277.         // Identifico Servizio per comprendere correttamente il messageType
  278.         ServiceIdentificationReader serviceIdentificationReader = null;
  279.         try{
  280.             serviceIdentificationReader = ServicesUtils.getServiceIdentificationReader(logCore, requestInfo,
  281.                     configPdDManager.getRegistroServiziManager(), configPdDManager);
  282.         }catch(Exception e){
  283.             String msg = "Inizializzazione RegistryReader fallita: "+Utilities.readFirstErrorValidMessageFromException(e);
  284.             logCore.error(msg,e);
  285.             ConnectorDispatcherErrorInfo cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore,
  286.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  287.                         get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA),
  288.                         IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, e, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  289.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfo);
  290.             return;
  291.         }
  292.         
  293.         // Provo a creare un context (per l'id di transazione nei diagnostici)
  294.         RicezioneContenutiApplicativiContext context = null;
  295.         IProtocolFactory<?> protocolFactory = null;
  296.         String idTransazione = null;
  297.         try {
  298.             context = new RicezioneContenutiApplicativiContext(idModuloAsService,dataAccettazioneRichiesta,requestInfo);
  299.             protocolFactory = req.getProtocolFactory();
  300.             idTransazione = (String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  301.         }catch(Throwable e) {
  302.             context = null;
  303.             protocolFactory = null;
  304.             // non loggo l'errore tanto poi provo a ricreare il context subito dopo e li verra' registrato l'errore
  305.         }
  306.         
  307.         try{
  308.             GestoreRichieste.readRequestConfig(requestInfo);
  309.         }catch(Exception e){
  310.             String msg = "GestoreRichieste readRequestConfig fallita: "+Utilities.readFirstErrorValidMessageFromException(e);
  311.             logCore.error(msg,e);
  312.             ConnectorDispatcherErrorInfo cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore,
  313.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  314.                         get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_500_ERRORE_INTERNO),
  315.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, e, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  316.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfo);
  317.             return;
  318.         }
  319.         
  320.         if(idTransazione!=null) {
  321.             try {
  322.                 if(openSPCoopProperties.isTransazioniEnabled()) {
  323.                     TransactionContext.createTransaction(idTransazione, "RicezioneContenutiApplicativi.1");
  324.                 }
  325.                 requestInfo.setIdTransazione(idTransazione);
  326.                 
  327.                 req.setThresholdContext((context!=null ? context.getPddContext(): null), 
  328.                         openSPCoopProperties.getDumpBinarioInMemoryThreshold(), openSPCoopProperties.getDumpBinarioRepository());
  329.                 
  330.             }catch(Throwable e) {
  331.                 context = null;
  332.                 protocolFactory = null;
  333.                 // non loggo l'errore tanto poi provo a ricreare il context subito dopo e li verra' registrato l'errore
  334.             }
  335.         }
  336.                 
  337.         // Logger dei messaggi diagnostici
  338.         String nomePorta = requestInfo.getProtocolContext().getInterfaceName();
  339.         MsgDiagnostico msgDiag = MsgDiagnostico.newInstance(TipoPdD.DELEGATA,idModulo,nomePorta,requestInfo);
  340.         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_CONTENUTI_APPLICATIVI);
  341.         if(context!=null && protocolFactory!=null) {
  342.             msgDiag.setPddContext(context.getPddContext(), protocolFactory);
  343.         }
  344.         
  345.         try{
  346.             msgDiag.logPersonalizzato("ricezioneRichiesta.firstLog");
  347.         }catch(Exception e){
  348.             logCore.error("Errore generazione diagnostico di ingresso",e);
  349.         }
  350.         
  351.         try{
  352.             req.setDiagnosticProducer(context!=null ? context.getPddContext(): null, msgDiag);
  353.         }catch(Throwable e){
  354.             logCore.error("Errore registrazione diagnostico sulla richiesta",e);
  355.         }
  356.         
  357.         // emitDiagnostic preAccept handler
  358.         GestoreHandlers.emitDiagnostic(msgDiag, preInAcceptRequestContext, context!=null ? context.getPddContext() : null, 
  359.                 logCore, logCore);
  360.         
  361.         // Aggiorno RequestInfo
  362.         try{
  363.             msgDiag.mediumDebug("Accesso configurazione della richiesta in corso...");
  364.         }catch(Exception e){
  365.             logCore.error("Errore generazione diagnostico",e);
  366.         }
  367.         ConnectorDispatcherInfo cInfo = RicezioneContenutiApplicativiServiceUtils.updatePortaDelegataRequestInfo(requestInfo, logCore, req, res,
  368.                 this.generatoreErrore, serviceIdentificationReader, msgDiag, 
  369.                 context!=null ? context.getPddContext(): null);
  370.         if(cInfo!=null){
  371.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(context, logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfo);
  372.             return; // l'errore in response viene impostato direttamente dentro il metodo
  373.         }
  374.         req.updateRequestInfo(requestInfo);
  375.                     
  376.         // Timeout, DimensioneMessaggi e DumpRaw
  377.         DumpRaw dumpRaw = null;
  378.         try{
  379.             try{
  380.                 msgDiag.mediumDebug("Lettura configurazione dump binario ...");
  381.             }catch(Exception e){
  382.                 logCore.error("Errore generazione diagnostico",e);
  383.             }
  384.             boolean dumpBinario = configPdDManager.dumpBinarioPD();
  385.             PortaDelegata pd = null;
  386.             if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  387.                 IDPortaDelegata idPD = new IDPortaDelegata();
  388.                 idPD.setNome(requestInfo.getProtocolContext().getInterfaceName());
  389.                 pd = configPdDManager.getPortaDelegataSafeMethod(idPD,requestInfo);
  390.             }

  392.             // Limited
  393.             try{
  394.                 msgDiag.mediumDebug("Lettura configurazione dimensione massima della richiesta ...");
  395.             }catch(Exception e){
  396.                 logCore.error("Errore generazione diagnostico",e);
  397.             }
  398.             String azione = (requestInfo!=null && requestInfo.getIdServizio()!=null) ? requestInfo.getIdServizio().getAzione() : null;
  399.             SoglieDimensioneMessaggi limitedInputStream = configPdDManager.getSoglieLimitedInputStream(pd, azione, idModulo,
  400.                     (context!=null && context.getPddContext()!=null) ? context.getPddContext() : null, 
  401.                     requestInfo,
  402.                     protocolFactory, logCore);
  403.             if(limitedInputStream!=null) {
  404.                 req.setRequestLimitedStream(limitedInputStream.getRichiesta());
  405.                 if(context!=null && context.getPddContext()!=null) {
  406.                     context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.LIMITED_STREAM, limitedInputStream.getRisposta());
  407.                 }
  408.             }
  409.             else {
  410.                 if(!openSPCoopProperties.isLimitedInputStreamThresholdDefined()) {
  411.                     req.disableLimitedStream();
  412.                 }
  413.             }
  414.             
  415.             // Timeout
  416.             try{
  417.                 msgDiag.mediumDebug("Lettura configurazione timeout per la lettura della richiesta ...");
  418.             }catch(Exception e){
  419.                 logCore.error("Errore generazione diagnostico",e);
  420.             }
  421.             boolean useTimeoutInputStream = configPdDManager.isConnettoriUseTimeoutInputStream(pd);
  422.             if(useTimeoutInputStream) {
  423.                 SogliaReadTimeout timeout = configPdDManager.getRequestReadTimeout(pd,
  424.                         requestInfo,
  425.                         protocolFactory, 
  426.                         context!=null ? context.getPddContext() : null,
  427.                         null);
  428.                 if(timeout!=null && timeout.getSogliaMs()>0) {
  429.                     req.setRequestReadTimeout(timeout);
  430.                 }
  431.                 else {
  432.                     req.disableReadTimeout();
  433.                 }
  434.             }
  435.             else {
  436.                 req.disableReadTimeout();
  437.             }
  438.             
  439.             // DumpRaw
  440.             try{
  441.                 msgDiag.mediumDebug("Lettura configurazione dump ...");
  442.             }catch(Exception e){
  443.                 logCore.error("Errore generazione diagnostico",e);
  444.             }
  445.             DumpConfigurazione dumpConfigurazione = configPdDManager.getDumpConfigurazione(pd);
  446.             ConfigurazioneTracciamento configurazioneTracciamento = new ConfigurazioneTracciamento(logCore, configPdDManager, pd);
  447.             boolean fileTraceHeaders = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioHeaderEnabled();
  448.             boolean fileTracePayload = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioPayloadEnabled();
  449.             dumpRaw = new DumpRaw(logCore,requestInfo.getIdentitaPdD(), idModulo, TipoPdD.DELEGATA, 
  450.                     dumpBinario, 
  451.                     dumpConfigurazione,
  452.                     fileTraceHeaders, fileTracePayload);
  453.             if(dumpRaw.isActiveDumpRichiesta()) {
  454.                 req = new DumpRawConnectorInMessage(logCore, req, 
  455.                         (context!=null ? context.getPddContext(): null), 
  456.                         openSPCoopProperties.getDumpBinarioInMemoryThreshold(), openSPCoopProperties.getDumpBinarioRepository());
  457.             }
  458.             if(dumpRaw.isActiveDumpRisposta()) {
  459.                 res = new DumpRawConnectorOutMessage(logCore, res, 
  460.                         (context!=null ? context.getPddContext(): null), 
  461.                         openSPCoopProperties.getDumpBinarioInMemoryThreshold(), openSPCoopProperties.getDumpBinarioRepository(),
  462.                         dumpRaw);
  463.             }
  464.         }catch(Throwable e){
  465.             String msg = "Inizializzazione di GovWay non correttamente effettuata: DumpRaw";
  466.             logCore.error(msg,  e);
  467.             cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore, 
  468.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  469.                         get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA), 
  470.                         IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, e, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  471.             RicezioneContenutiApplicativiServiceUtils.emitTransaction(logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfo);
  472.             return;
  473.         }
  474.         
  475.         // API Soap supporta solo POST e ?wsdl
  476.         if(ServiceBinding.SOAP.equals(requestInfo.getIntegrationServiceBinding())){
  477.             HttpRequestMethod method = null;
  478.             if(req!=null && req.getURLProtocolContext()!=null && req.getURLProtocolContext().getRequestType()!=null) {
  479.                 try {
  480.                     method = HttpRequestMethod.valueOf(req.getURLProtocolContext().getRequestType());
  481.                 }catch(Exception e) {
  482.                     // ignore
  483.                 }
  484.             }
  485.             if(method!=null && !HttpRequestMethod.POST.equals(method)){
  486.                 if(ServicesUtils.isRequestWsdl(req, logCore)) {
  487.                     try {
  488.                         ServicesUtils.writeWsdl(res, requestInfo, RicezioneContenutiApplicativiConnector.ID_SERVICE, serviceIdentificationReader, logCore);
  489.                     }catch(Exception e) {
  490.                         String msg = "Lettura wsdl fallita: "+Utilities.readFirstErrorValidMessageFromException(e);
  491.                         logCore.error(msg,e);
  492.                         cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore,
  493.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  494.                                     get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_500_ERRORE_INTERNO),
  495.                                     IntegrationFunctionError.INTERNAL_REQUEST_ERROR, e, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  496.                         // nel caso di wsdl request non emetto la transazione
  497.                         //RicezioneContenutiApplicativiServiceUtils.emitTransaction(context,logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfo);
  498.                     }finally {
  499.                         // FIX devo però rilasciare dalla memoria la transazione:
  500.                         if(openSPCoopProperties.isTransazioniEnabled()) {
  501.                             idTransazione = (String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  502.                             TransactionContext.removeTransaction(idTransazione);
  503.                         }
  504.                     }
  505.                     return;
  506.                 }
  507.                 else {
  508.                     String msg = "Metodo http '"+method+"' non supportato dall'API SOAP invocata";
  509.                     logCore.error(msg);
  510.                     ConnectorDispatcherErrorInfo cInfoError =  ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore,
  511.                             ErroriIntegrazione.ERRORE_439_FUNZIONALITA_NOT_SUPPORTED_BY_PROTOCOL.getErrore439_FunzionalitaNotSupportedByProtocol(msg, protocolFactory),
  512.                             IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL, null, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  513.                     RicezioneContenutiApplicativiServiceUtils.emitTransaction(context,logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfoError);
  514.                     return;
  515.                 }
  516.             }
  517.         }
  518.         
  519.         


  522.         
  523.         /* ------------  Lettura parametri della richiesta ------------- */

  525.         //  Risposta Soap
  526.         OpenSPCoop2Message responseMessage = null;
  527.                 
  528.         // PostOutResponseContext
  529.         PostOutResponseContext postOutResponseContext = null;
  530.         
  531.         PdDContext pddContext = null;
  532.         OpenSPCoop2Message requestMessage = null;
  533.         String protocol = null;
  534.         MessageType messageTypeReq = null;
  535.         ServiceBinding integrationServiceBinding = null;
  536.         try{
  537.             
  538.             /* --------------- Creo il context che genera l'id univoco ----------------------- */
  539.             
  540.             try{
  541.                 msgDiag.mediumDebug("Creazione contesto ...");
  542.             }catch(Exception e){
  543.                 logCore.error("Errore generazione diagnostico",e);
  544.             }
  545.             
  546.             if(protocolFactory==null) {
  547.                 protocolFactory = req.getProtocolFactory();
  548.             }
  549.             protocol = protocolFactory.getProtocol();
  550.                     
  551.             integrationServiceBinding = requestInfo.getIntegrationServiceBinding();
  552.             
  553.             if(context==null) {
  554.                 context = new RicezioneContenutiApplicativiContext(idModuloAsService,dataAccettazioneRichiesta,requestInfo);
  555.             }
  556.             if(preInAcceptRequestContext!=null && preInAcceptRequestContext.getPreContext()!=null && !preInAcceptRequestContext.getPreContext().isEmpty()) {
  557.                 context.getPddContext().addAll(preInAcceptRequestContext.getPreContext(), false);
  558.             }
  559.             context.setTipoPorta(TipoPdD.DELEGATA);
  560.             context.setIdModulo(idModulo);
  561.             context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME, protocolFactory.getProtocol());
  562.             context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO, req.getRequestInfo());
  563.             RicezionePropertiesConfig rConfig = RicezioneContenutiApplicativiServiceUtils.readPropertiesConfig(req.getRequestInfo(), logCore,null);
  564.             if(rConfig!=null) {
  565.                 if (rConfig.getApiImplementation() != null && !rConfig.getApiImplementation().isEmpty()) {
  566.                    context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_CONFIGURAZIONE, rConfig.getApiImplementation());
  567.                 }
  568.                 if (rConfig.getSoggettoFruitore() != null && !rConfig.getSoggettoFruitore().isEmpty()) {
  569.                     context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_FRUITORE, rConfig.getSoggettoFruitore());
  570.                 }
  571.                 if (rConfig.getSoggettoErogatore() != null && !rConfig.getSoggettoErogatore().isEmpty()) {
  572.                     context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_EROGATORE, rConfig.getSoggettoErogatore());
  573.                 }
  574.             }
  575.             context.setProprietaErroreAppl(this.generatoreErrore.getProprietaErroreAppl());
  576.             msgDiag.setPddContext(context.getPddContext(), protocolFactory);
  577.             pddContext = context.getPddContext();
  578.             
  579.             try{
  580.                 if(openSPCoopProperties.isTransazioniEnabled()) {
  581.                     // NOTA: se gia' esiste con l'id di transazione, non viene ricreata
  582.                     TransactionContext.createTransaction((String)pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE), "RicezioneContenutiApplicativi.2");
  583.                 }
  584.             }catch(Exception e){
  585.                 logCore.error("Errore durante la creazione della transazione",e);
  586.             }
  587.             
  588.             try{
  589.                 msgDiag.logPersonalizzato("ricezioneRichiesta.firstAccessRequestStream");
  590.             }catch(Exception e){
  591.                 logCore.error("Errore generazione diagnostico di ingresso (stream access)",e);
  592.             }
  593.             
  594.             if(dumpRaw!=null && dumpRaw.isActiveDump()){
  595.                 dumpRaw.setPddContext(msgDiag.getPorta(), context.getPddContext());
  596.                 dumpRaw.serializeContext(context, protocol);
  597.             }
  598.             
  599.             DirectVMConnectorInMessage vm = null;
  600.             if(req instanceof DirectVMConnectorInMessage){
  601.                 vm = (DirectVMConnectorInMessage) req;
  602.             }
  603.             else if(req instanceof DumpRawConnectorInMessage){
  604.                 if( ((DumpRawConnectorInMessage)req).getWrappedConnectorInMessage() instanceof DirectVMConnectorInMessage ){
  605.                     vm = (DirectVMConnectorInMessage) ((DumpRawConnectorInMessage)req).getWrappedConnectorInMessage();
  606.                 }
  607.             }
  608.             if(vm!=null && vm.getDirectVMProtocolInfo()!=null){
  609.                 vm.getDirectVMProtocolInfo().setInfo(pddContext);
  610.             }
  611.             
  612.             
  613.             
  614.             
  615.             /* ------------  PostOutResponseContext ------------- */
  616.             
  617.             postOutResponseContext = new PostOutResponseContext(logCore,protocolFactory);
  618.             postOutResponseContext.setTipoPorta(TipoPdD.DELEGATA);
  619.             postOutResponseContext.setPddContext(pddContext);
  620.             postOutResponseContext.setIdModulo(idModulo);
  621.             
  622.             
  623.             
  624.             
  625.             /* ------------  PreInHandler ------------- */
  626.             
  627.             // build context
  628.             PreInRequestContext preInRequestContext = new PreInRequestContext(pddContext);
  629.             if(pddContextFromServlet!=null){
  630.                 preInRequestContext.getPddContext().addAll(pddContextFromServlet, true);
  631.             }
  632.             preInRequestContext.setTipoPorta(TipoPdD.DELEGATA);
  633.             preInRequestContext.setIdModulo(idModulo);
  634.             preInRequestContext.setProtocolFactory(protocolFactory);
  635.             preInRequestContext.setRequestInfo(requestInfo);
  636.             Map<String, Object> transportContext = new HashMap<>();
  637.             transportContext.put(PreInRequestContext.SERVLET_REQUEST, req);
  638.             transportContext.put(PreInRequestContext.SERVLET_RESPONSE, res);
  639.             preInRequestContext.setTransportContext(transportContext);  
  640.             preInRequestContext.setLogCore(logCore);
  641.             
  642.             // invocazione handler
  643.             GestoreHandlers.preInRequest(preInRequestContext, msgDiag, logCore);
  644.             
  645.             // aggiungo eventuali info inserite nel preInHandler
  646.             pddContext.addAll(preInRequestContext.getPddContext(), false);
  647.             
  648.             // Lettura risposta parametri NotifierInputStream
  649.             NotifierInputStreamParams notifierInputStreamParams = preInRequestContext.getNotifierInputStreamParams();
  650.             context.setNotifierInputStreamParams(notifierInputStreamParams);
  651.             
  652.             // Controllo Content Length se attiva una policy di rate limiting
  653.             req.checkContentLengthLimit();
  654.             
  655.             // Lettura richiesta con il dump
  656.             if(dumpRaw!=null && dumpRaw.isActiveDumpRichiesta()){
  657.                 dumpRaw.serializeRequest(((DumpRawConnectorInMessage)req), true, notifierInputStreamParams);
  658.                 dataIngressoRichiesta = req.getDataIngressoRichiesta();
  659.                 context.setDataIngressoRichiesta(dataIngressoRichiesta);
  660.             }
  661.             
  662.             
  663.                 
  664.             
  665.             
  666.             /* ------------ Controllo ContentType -------------------- */
  667.             
  668.             msgDiag.logPersonalizzato("ricezioneRichiesta.elaborazioneDati.tipologiaMessaggio");
  669.             
  670.             messageTypeReq = requestInfo.getIntegrationRequestMessageType();
  671.             if(ServiceBinding.SOAP.equals(integrationServiceBinding) && messageTypeReq!=null){
  672.                 msgDiag.addKeyword(CostantiPdD.KEY_SOAP_VERSION, messageTypeReq.getMessageVersionAsString());
  673.                 msgDiag.addKeyword(CostantiPdD.KEY_SOAP_ENVELOPE_NAMESPACE_ATTESO, SoapUtils.getSoapEnvelopeNS(messageTypeReq));
  674.             }
  675.             
  676.             String contentTypeReq = req.getContentType();
  677.             boolean contentTypeSupportato = messageTypeReq!=null;
  678.             msgDiag.addKeyword(CostantiPdD.KEY_CONTENT_TYPES_ATTESI, 
  679.                     requestInfo.getBindingConfig().getContentTypesSupportedAsString(integrationServiceBinding, 
  680.                             MessageRole.REQUEST,requestInfo.getProtocolContext()));
  681.             List<String> supportedContentTypes = requestInfo.getBindingConfig().getContentTypesSupported(integrationServiceBinding, 
  682.                     MessageRole.REQUEST,requestInfo.getProtocolContext()); 
  683.             msgDiag.addKeyword(CostantiPdD.KEY_HTTP_HEADER, contentTypeReq);
  684.             
  685.             if(ServiceBinding.SOAP.equals(integrationServiceBinding)){
  686.                 if(openSPCoopProperties.isControlloContentTypeAbilitatoRicezioneContenutiApplicativi() == false){
  687.                     if(!contentTypeSupportato){
  688.                         if(HttpConstants.CONTENT_TYPE_NON_PRESENTE.equals(contentTypeReq)){
  689.                             msgDiag.logPersonalizzato("contentType.notDefined");
  690.                         }else{
  691.                             msgDiag.logPersonalizzato("contentType.unsupported");
  692.                         }
  693.                         messageTypeReq = MessageType.SOAP_11;
  694.                         contentTypeReq = SoapUtils.getSoapContentTypeForMessageWithoutAttachments(messageTypeReq); // Forzo text/xml;
  695.                         logCore.warn("Content-Type non supportato, viene utilizzato forzatamente il tipo: "+contentTypeReq);
  696.                         contentTypeSupportato = true;
  697.                     }
  698.                 }
  699.             }
  700.             if(!contentTypeSupportato){
  701.                 
  702.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  703.                 
  704.                 // Leggo content Type dall'header HTTP per capire se l'header proprio non esiste o se e' il valore errato.
  705.                 if(HttpConstants.CONTENT_TYPE_NON_PRESENTE.equals(contentTypeReq)){
  706.                     //ContentType del messaggio non presente
  707.                     msgDiag.logPersonalizzato("contentType.notDefined");
  708.                     responseMessage = this.generatoreErrore.build(pddContext, IntegrationFunctionError.CONTENT_TYPE_NOT_PROVIDED,
  709.                             ErroriIntegrazione.ERRORE_433_CONTENT_TYPE_NON_PRESENTE.
  710.                             getErrore433_ContentTypeNonPresente(supportedContentTypes),null,null);
  711.                 }
  712.                 else{
  713.                     //ContentType del messaggio non supportato
  714.                     msgDiag.logPersonalizzato("contentType.unsupported");
  715.                     responseMessage = this.generatoreErrore.build(pddContext, IntegrationFunctionError.CONTENT_TYPE_NOT_SUPPORTED,
  716.                             ErroriIntegrazione.ERRORE_429_CONTENT_TYPE_NON_SUPPORTATO.
  717.                             getErrore429_ContentTypeNonSupportato(contentTypeReq,supportedContentTypes),null,null);
  718.                 }
  719.             }
  720.             else{
  721.                 /* ------------ Check Charset ------------- */
  722.                 try {
  723.                     boolean checkEnabled = false;
  724.                     List<String> ctDefault = null;
  725.                     if(ServiceBinding.SOAP.equals(integrationServiceBinding)){
  726.                         if(openSPCoopProperties.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap()) {
  727.                             checkEnabled = true;
  728.                             ctDefault = openSPCoopProperties.getControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap();
  729.                         }
  730.                     }
  731.                     else {
  732.                         if(openSPCoopProperties.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest()) {
  733.                             checkEnabled = true;
  734.                             ctDefault = openSPCoopProperties.getControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest();
  735.                         }
  736.                     }
  737.                     if(checkEnabled) {
  738.                         ServicesUtils.checkCharset(contentTypeReq, ctDefault, msgDiag, true, TipoPdD.DELEGATA);
  739.                     }
  740.                     
  741.                 }catch(Throwable t) {
  742.                     logCore.error("Avvenuto errore durante il controllo del charset della richiesta: "+t.getMessage(),t);
  743.                 }
  744.                 
  745.                 /* ------------  SoapAction check 1 (controlla che non sia null e ne ritorna il valore) ------------- */            
  746.                 String soapAction = null;
  747.                 try{
  748.                     if(ServiceBinding.SOAP.equals(integrationServiceBinding)){
  749.                         soapAction = req.getSOAPAction();
  750.                     }
  751.                 }catch(Exception e){
  752.                     if(dataIngressoRichiesta==null) {
  753.                         dataIngressoRichiesta=DateManager.getDate();
  754.                     }
  755.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  756.                     throw e;
  757.                 }
  758.                 
  759.                 /* ------------ Costruzione Messaggio -------------------- */
  760.                 msgDiag.logPersonalizzato("ricezioneRichiesta.elaborazioneDati.inCorso");
  761.                 Utilities.printFreeMemory("RicezioneContenutiApplicativi - Pre costruzione richiesta");
  762.                 OpenSPCoop2MessageParseResult pr = req.getRequest(notifierInputStreamParams);
  763.                 if(pr.getParseException()!=null){
  764.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, pr.getParseException());
  765.                 }
  766.                 dataIngressoRichiesta = req.getDataIngressoRichiesta();
  767.                 context.setDataIngressoRichiesta(dataIngressoRichiesta);
  768.                 requestMessage = pr.getMessage_throwParseException();
  769.                 Utilities.printFreeMemory("RicezioneContenutiApplicativi - Post costruzione richiesta");
  770.                 requestMessage.setProtocolName(protocolFactory.getProtocol());
  771.                 requestMessage.setTransactionId(PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext));
  772.                 requestMessage.addContextProperty(org.openspcoop2.core.constants.Costanti.REQUEST_INFO,requestInfo); // serve nelle comunicazione non stateless (es. riscontro salvato) per poterlo rispedire
  773.                 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
  774.                 Object nomePortaInvocataObject = context.getPddContext().getObject(CostantiPdD.NOME_PORTA_INVOCATA);
  775.                 if(nomePortaInvocataObject!=null && nomePortaInvocataObject instanceof String) {
  776.                     requestMessage.addContextProperty(CostantiPdD.NOME_PORTA_INVOCATA, (String) nomePortaInvocataObject );
  777.                 }
  778.                                 
  779.                 /* ------------ Controllo Soap namespace -------------------- */
  780.                 String soapEnvelopeNamespaceVersionMismatch = null;
  781.                 try{
  782.                     if(ServiceBinding.SOAP.equals(integrationServiceBinding)){
  783.                         soapEnvelopeNamespaceVersionMismatch = ServicesUtils.checkSOAPEnvelopeNamespace(requestMessage.castAsSoap(), messageTypeReq);
  784.                     }
  785.                 }catch(Exception e){
  786.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  787.                     throw e;
  788.                 }
  789.                 
  790.                 /* ------------ Controllo MustUnderstand -------------------- */
  791.                 String mustUnderstandError = null;
  792.                 if(soapEnvelopeNamespaceVersionMismatch==null) {
  793.                     try{
  794.                         if(ServiceBinding.SOAP.equals(integrationServiceBinding)){
  795.                             mustUnderstandError = ServicesUtils.checkMustUnderstand(requestMessage.castAsSoap(),protocolFactory);
  796.                         }
  797.                     }catch(Exception e){
  798.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  799.                         throw e;
  800.                     }
  801.                 }
  802.                 
  803.                 /* ------------  SoapAction check 2 ------------- */
  804.                 if(soapAction!=null){
  805.                     if(openSPCoopProperties.checkSoapActionQuotedString_ricezioneContenutiApplicativi()){
  806.                         try{
  807.                             SoapUtils.checkSoapActionQuotedString(soapAction, messageTypeReq);
  808.                         }catch(Exception e){
  809.                             pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  810.                             throw e;
  811.                         }
  812.                     }
  813.                 }
  814.                 
  815.                 /* --------------- SecurityToken --------------- */
  816.                 try {
  817.                     if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getCredential()!=null && 
  818.                             requestInfo.getProtocolContext().getCredential().getCertificate()!=null &&
  819.                             requestInfo.getProtocolContext().getCredential().getCertificate().getCertificate()!=null) {
  820.                         SecurityTokenUtilities.newSecurityToken(pddContext);
  821.                     }
  822.                 }catch(Exception e){
  823.                     logCore.error("Costruzione SecurityToken non riuscito: "+e.getMessage(),e);
  824.                 }
  825.                             
  826.                 /* ------------  Elaborazione ------------- */
  827.             
  828.                 if(mustUnderstandError==null && soapEnvelopeNamespaceVersionMismatch==null){
  829.                 
  830.                     // Contesto di Richiesta
  831.                     context.setCredenziali(new Credenziali(req.getCredential()));
  832.                     context.setGestioneRisposta(true); // siamo in una servlet, la risposta deve essere aspettata
  833.                     context.setInvocazionePDPerRiferimento(false); // la PD con questa servlet non effettuera' mai invocazioni per riferimento.
  834.                     context.setMessageRequest(requestMessage);
  835.                     context.setUrlProtocolContext(requestInfo.getProtocolContext());
  836.                     context.setMsgDiagnostico(msgDiag);
  837.     
  838.                     // Log elaborazione dati completata
  839.                     msgDiag.logPersonalizzato("ricezioneRichiesta.elaborazioneDati.completata");
  840.             
  841.                     // se il tracciamento lo prevedo emetto un log
  842.                     registraTracciaInRequest(context, protocolFactory, logCore, msgDiag);
  843.                     
  844.                     // Invocazione...
  845.                     RicezioneContenutiApplicativi gestoreRichiesta = new RicezioneContenutiApplicativi(context, this.generatoreErrore);
  846.                     gestoreRichiesta.process(req);
  847.                     responseMessage = context.getMessageResponse();
  848.                 }   
  849.                 else{
  850.                     if(mustUnderstandError!=null){
  851.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  852.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, mustUnderstandError);
  853.                         msgDiag.logPersonalizzato("mustUnderstand.unknown");
  854.                         responseMessage = this.generatoreErrore.build(pddContext, IntegrationFunctionError.SOAP_MUST_UNDERSTAND_UNKNOWN,
  855.                                 ErroriIntegrazione.ERRORE_427_MUSTUNDERSTAND_ERROR.
  856.                                 getErrore427_MustUnderstandHeaders(mustUnderstandError),null,null);
  857.                     }
  858.                     else{
  859.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  860.                         msgDiag.addKeyword(CostantiPdD.KEY_SOAP_ENVELOPE_NAMESPACE, soapEnvelopeNamespaceVersionMismatch);
  861.                         msgDiag.logPersonalizzato("soapEnvelopeNamespace.versionMismatch");
  862.                         responseMessage = this.generatoreErrore.build(pddContext, IntegrationFunctionError.SOAP_VERSION_MISMATCH,
  863.                                 ErroriIntegrazione.ERRORE_430_SOAP_ENVELOPE_NAMESPACE_ERROR.
  864.                                 getErrore430_SoapNamespaceNonSupportato(messageTypeReq, soapEnvelopeNamespaceVersionMismatch),null,null);
  865.                     }
  866.                 }
  867.             }
  868.             
  869.         }
  870.         catch (Throwable e) {
  871.             
  872.             if(context==null){
  873.                 // Errore durante la generazione dell'id
  874.                 context = RicezioneContenutiApplicativiContext.newRicezioneContenutiApplicativiContext(idModuloAsService,dataAccettazioneRichiesta,requestInfo);
  875.                 context.setDataIngressoRichiesta(dataIngressoRichiesta);
  876.                 context.setTipoPorta(TipoPdD.DELEGATA);
  877.                 context.setIdModulo(idModulo);
  878.                 context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME, protocolFactory.getProtocol());
  879.                 pddContext = context.getPddContext();
  880.                 if(postOutResponseContext!=null){
  881.                     postOutResponseContext.setPddContext(pddContext);
  882.                 }
  883.                 msgDiag.setPddContext(pddContext, protocolFactory);
  884.             }
  885.             
  886.             // Se viene lanciata una eccezione, riguarda la richiesta, altrimenti è gestita dopo nel finally.
  887.             Throwable tParsing = null;
  888.             ParseException parseException = null;
  889.             if(pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION)){
  890.                 parseException = (ParseException) pddContext.removeObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);            
  891.                 if(parseException!=null) {
  892.                     tParsing = parseException.getParseException();
  893.                 }
  894.             }
  895.             if(tParsing==null && (requestMessage==null || requestMessage.getParseException() == null)){
  896.                 tParsing = ParseExceptionUtils.getParseException(e);
  897.             }
  898.             
  899.             // Genero risposta con errore
  900.             String msgErrore = e.getMessage();
  901.             if(msgErrore==null){
  902.                 msgErrore = e.toString();
  903.             }
  904.             if( ServiceBinding.SOAP.equals(integrationServiceBinding) &&
  905.                 messageTypeReq!=null &&
  906.                     (
  907.                             // Messaggio lanciato dallo streaming engine
  908.                         msgErrore.equals("Transport level information does not match with SOAP Message namespace URI") ||
  909.                         // ?
  910.                         msgErrore.equals("I dati ricevuti non rappresentano un messaggio SOAP 1.1 valido: ") ||
  911.                         // I seguenti due errori invece vengono lanciati dalle classi 'com/sun/xml/messaging/saaj/soap/ver1_2/SOAPPart1_2Impl.java' e com/sun/xml/messaging/saaj/soap/ver1_1/SOAPPart1_1Impl.java
  912.                         // Proprio nel caso il namespace non corrisponde al tipo atteso.
  913.                         msgErrore.equals("InputStream does not represent a valid SOAP 1.1 Message") || 
  914.                         msgErrore.equals("InputStream does not represent a valid SOAP 1.2 Message")
  915.                     )
  916.                 ){
  917.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  918.                 msgDiag.addKeyword(CostantiPdD.KEY_SOAP_ENVELOPE_NAMESPACE, "Impossibile recuperare il valore del namespace");
  919.                 msgDiag.logPersonalizzato("soapEnvelopeNamespace.versionMismatch");
  920.                 responseMessage = this.generatoreErrore.build(pddContext, IntegrationFunctionError.SOAP_VERSION_MISMATCH,
  921.                         ErroriIntegrazione.ERRORE_430_SOAP_ENVELOPE_NAMESPACE_ERROR.
  922.                         getErrore430_SoapNamespaceNonSupportato(messageTypeReq, "Impossibile recuperare il valore del namespace"),e,null);
  923.             } else if(tParsing!=null){
  924.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  925.                 msgErrore = tParsing.getMessage();
  926.                 if(msgErrore==null){
  927.                     msgErrore = tParsing.toString();
  928.                 }
  929.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  930.                 logCore.error("parsingExceptionRichiesta",e);
  931.                 msgDiag.logPersonalizzato("parsingExceptionRichiesta");
  932.                 
  933.                 IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.UNPROCESSABLE_REQUEST_CONTENT;
  934.                 if( parseException!=null && parseException.getSourceException()!=null &&
  935.                         TimeoutIOException.isTimeoutIOException(parseException.getSourceException())) {
  936.                     integrationFunctionError = IntegrationFunctionError.REQUEST_TIMED_OUT;
  937.                 }
  938.                 else if( parseException!=null && parseException.getSourceException()!=null &&
  939.                         LimitExceededIOException.isLimitExceededIOException(parseException.getSourceException())) {
  940.                     integrationFunctionError = IntegrationFunctionError.REQUEST_SIZE_EXCEEDED;
  941.                 }
  942.                 
  943.                 responseMessage = this.generatoreErrore.build(pddContext, integrationFunctionError,
  944.                         ErroriIntegrazione.ERRORE_432_PARSING_EXCEPTION_RICHIESTA.
  945.                         getErrore432_MessaggioRichiestaMalformato(tParsing),tParsing,null);
  946.             } 
  947.             else if (e instanceof HandlerException) {
  948.                 logCore.error("ErroreGenerale (HandlerException)",e);
  949.                 HandlerException he = (HandlerException) e;
  950.                 if(he.isEmettiDiagnostico()) {
  951.                     msgDiag.logErroreGenerico(e, "Generale(richiesta-handler)");
  952.                 }
  953.                 ErroreIntegrazione errore = he.convertToErroreIntegrazione();
  954.                 if(errore==null) {
  955.                     errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento("Generale(richiesta)");
  956.                 }
  957.                 IntegrationFunctionError integrationError = he.getIntegrationFunctionError();
  958.                 if(integrationError==null) {
  959.                     integrationError = IntegrationFunctionError.BAD_REQUEST;
  960.                 }
  961.                 responseMessage = this.generatoreErrore.build(pddContext,integrationError,errore,e,null);
  962.                 he.customized(responseMessage);
  963.             }
  964.             else {
  965.                 logCore.error("ErroreGenerale",e);
  966.                 msgDiag.logErroreGenerico(e, "Generale(richiesta)");
  967.                 responseMessage = this.generatoreErrore.build(pddContext, IntegrationFunctionError.BAD_REQUEST,
  968.                         ErroriIntegrazione.ERRORE_426_SERVLET_ERROR.
  969.                         getErrore426_ServletError(true, e),e,null);
  970.             }
  971.         }
  972.         finally{
  973.             
  974.             try {
  975.                 GestoreRichieste.saveRequestConfig(requestInfo);
  976.             }catch(Throwable e) {
  977.                 logCore.error("Errore durante il salvataggio dei dati della richiesta: "+e.getMessage(),e);
  978.             }

  980.             String requestReadTimeout = null;
  981.             String responseReadTimeout = null;
  982.             if(pddContext!=null && pddContext.containsKey(TimeoutInputStream.ERROR_MSG_KEY)) {
  983.                 String timeoutMessage = PdDContext.getValue(TimeoutInputStream.ERROR_MSG_KEY, pddContext);
  984.                 if(timeoutMessage!=null && timeoutMessage.startsWith(CostantiPdD.PREFIX_TIMEOUT_REQUEST)) {
  985.                     requestReadTimeout = timeoutMessage;
  986.                 }
  987.                 else if(timeoutMessage!=null && timeoutMessage.startsWith(CostantiPdD.PREFIX_TIMEOUT_RESPONSE)) {
  988.                     responseReadTimeout = timeoutMessage;
  989.                 }
  990.             }
  991.             String requestLimitExceeded = null;
  992.             String responseLimitExceeded = null;
  993.             if(pddContext!=null && pddContext.containsKey(LimitedInputStream.ERROR_MSG_KEY)) {
  994.                 String limitedExceededMessage = PdDContext.getValue(LimitedInputStream.ERROR_MSG_KEY, pddContext);
  995.                 if(limitedExceededMessage!=null && limitedExceededMessage.startsWith(CostantiPdD.PREFIX_LIMITED_REQUEST)) {
  996.                     requestLimitExceeded = limitedExceededMessage;
  997.                 }
  998.                 else if(limitedExceededMessage!=null && limitedExceededMessage.startsWith(CostantiPdD.PREFIX_LIMITED_RESPONSE)) {
  999.                     responseLimitExceeded = limitedExceededMessage;
  1000.                 }
  1001.             }
  1002.             
  1003.             if((requestMessage!=null && requestMessage.getParseException() != null) || 
  1004.                     (pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION)) ||
  1005.                     requestReadTimeout!=null ||
  1006.                     requestLimitExceeded!=null){
  1007.                 if(pddContext!=null) {
  1008.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  1009.                 }
  1010.                 
  1011.                 ParseException parseException = null;
  1012.                 Throwable tParsing = null;
  1013.                 Throwable sParsing = null;
  1014.                 String msgErrore = null;
  1015.                 if(requestReadTimeout != null) {
  1016.                     tParsing = (TimeoutIOException) pddContext.getObject(TimeoutInputStream.EXCEPTION_KEY);
  1017.                     sParsing = tParsing;
  1018.                     msgErrore = tParsing.getMessage();
  1019.                 }
  1020.                 else if(requestLimitExceeded != null) {
  1021.                     tParsing = (LimitExceededIOException) pddContext.getObject(LimitedInputStream.EXCEPTION_KEY);
  1022.                     sParsing = tParsing;
  1023.                     msgErrore = tParsing.getMessage();
  1024.                 }
  1025.                 else if( requestMessage!=null && requestMessage.getParseException() != null ){
  1026.                     parseException = requestMessage.getParseException();
  1027.                     tParsing = parseException.getParseException();
  1028.                     sParsing = parseException.getSourceException();
  1029.                     msgErrore = tParsing.getMessage();
  1030.                 }
  1031.                 else {
  1032.                     parseException = (ParseException) pddContext.getObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  1033.                     tParsing = parseException.getParseException();
  1034.                     sParsing = parseException.getSourceException();
  1035.                     msgErrore = tParsing.getMessage();
  1036.                 }           
  1037.                 
  1038.                 if(msgErrore==null && tParsing!=null){
  1039.                     msgErrore = tParsing.toString();
  1040.                 }
  1041.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  1042.                 logCore.error("parsingExceptionRichiesta",sParsing);
  1043.                 msgDiag.logPersonalizzato("parsingExceptionRichiesta");
  1044.                 
  1045.                 IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.UNPROCESSABLE_REQUEST_CONTENT;
  1046.                 if(requestReadTimeout!=null) {
  1047.                     integrationFunctionError = IntegrationFunctionError.REQUEST_TIMED_OUT;
  1048.                 }
  1049.                 else if(requestLimitExceeded!=null) {
  1050.                     integrationFunctionError = IntegrationFunctionError.REQUEST_SIZE_EXCEEDED;
  1051.                 }
  1052.                 else if( parseException!=null && sParsing!=null &&
  1053.                         TimeoutIOException.isTimeoutIOException(sParsing)) {
  1054.                     integrationFunctionError = IntegrationFunctionError.REQUEST_TIMED_OUT;
  1055.                 }
  1056.                 else if( parseException!=null && sParsing!=null &&
  1057.                         LimitExceededIOException.isLimitExceededIOException(sParsing)) {
  1058.                     integrationFunctionError = IntegrationFunctionError.REQUEST_SIZE_EXCEEDED;
  1059.                 }
  1060.                 
  1061.                 responseMessage = this.generatoreErrore.build(pddContext, integrationFunctionError,
  1062.                         ErroriIntegrazione.ERRORE_432_PARSING_EXCEPTION_RICHIESTA.
  1063.                         getErrore432_MessaggioRichiestaMalformato(tParsing),
  1064.                         tParsing,null);
  1065.             }
  1066.             else if( (responseMessage!=null && responseMessage.getParseException() != null) ||
  1067.                     (pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION)) ||
  1068.                     responseReadTimeout!=null ||
  1069.                     responseLimitExceeded!=null){
  1070.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO, true);
  1071.                 
  1072.                 ParseException parseException = null;
  1073.                 Throwable tParsing = null;
  1074.                 Throwable sParsing = null;
  1075.                 String msgErrore = null;
  1076.                 if(responseReadTimeout != null) {
  1077.                     tParsing = (TimeoutIOException) pddContext.getObject(TimeoutInputStream.EXCEPTION_KEY);
  1078.                     sParsing = tParsing;
  1079.                     msgErrore = tParsing.getMessage();
  1080.                 }
  1081.                 else if(responseLimitExceeded != null) {
  1082.                     tParsing = (LimitExceededIOException) pddContext.getObject(LimitedInputStream.EXCEPTION_KEY);
  1083.                     sParsing = tParsing;
  1084.                     msgErrore = tParsing.getMessage();
  1085.                 }
  1086.                 else if( responseMessage!=null && responseMessage.getParseException() != null ){
  1087.                     parseException = responseMessage.getParseException();
  1088.                     tParsing = parseException.getParseException();
  1089.                     sParsing = parseException.getSourceException();
  1090.                     msgErrore = tParsing.getMessage();
  1091.                 }
  1092.                 else{
  1093.                     parseException = (ParseException) pddContext.getObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  1094.                     tParsing = parseException.getParseException();
  1095.                     sParsing = parseException.getSourceException();
  1096.                     msgErrore = tParsing.getMessage();
  1097.                 }

  1099.                 if(msgErrore==null && tParsing!=null){
  1100.                     msgErrore = tParsing.toString();
  1101.                 }           
  1102.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  1103.                 logCore.error("parsingExceptionRisposta",sParsing);
  1104.                 
  1105.                 IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.UNPROCESSABLE_RESPONSE_CONTENT;
  1106.                 if(responseReadTimeout!=null) {
  1107.                     integrationFunctionError = IntegrationFunctionError.ENDPOINT_REQUEST_TIMED_OUT;
  1108.                 }
  1109.                 else if(responseLimitExceeded!=null) {
  1110.                     integrationFunctionError = IntegrationFunctionError.RESPONSE_SIZE_EXCEEDED;
  1111.                 }
  1112.                 else if(sParsing!=null &&
  1113.                         TimeoutIOException.isTimeoutIOException(sParsing)) {
  1114.                     integrationFunctionError = IntegrationFunctionError.ENDPOINT_REQUEST_TIMED_OUT;
  1115.                 }
  1116.                 else if(sParsing!=null &&
  1117.                         LimitExceededIOException.isLimitExceededIOException(sParsing)) {
  1118.                     integrationFunctionError = IntegrationFunctionError.RESPONSE_SIZE_EXCEEDED;
  1119.                 }
  1120.                 
  1121.                 msgDiag.logPersonalizzato("parsingExceptionRisposta");
  1122.                 responseMessage = this.generatoreErrore.build(pddContext, integrationFunctionError,
  1123.                         ErroriIntegrazione.ERRORE_440_PARSING_EXCEPTION_RISPOSTA.
  1124.                         getErrore440_MessaggioRispostaMalformato(tParsing),
  1125.                         tParsing,null);
  1126.             }
  1127.             
  1128.             
  1129.             try{
  1130.                 // Se non sono stati recuperati i dati delle url, provo a recuperarli
  1131.                 URLProtocolContext urlProtocolContext = context!=null ? context.getUrlProtocolContext() : null;
  1132.                 if(urlProtocolContext==null){
  1133.                     urlProtocolContext = req.getURLProtocolContext();
  1134.                 }
  1135.                 if(urlProtocolContext!=null && pddContext!=null){
  1136.                     String urlInvocazione = urlProtocolContext.getUrlInvocazione_formBased();
  1137.                     if(urlProtocolContext.getFunction()!=null){
  1138.                         urlInvocazione = "["+urlProtocolContext.getFunction()+"] "+urlInvocazione;
  1139.                     }
  1140.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.URL_INVOCAZIONE, urlInvocazione);
  1141.                 }
  1142.             }catch(Throwable t){
  1143.                 // ignore
  1144.             }
  1145.             try{
  1146.                 Credenziali credenziali = context!=null ? context.getCredenziali() : null;
  1147.                 if(credenziali==null){
  1148.                     credenziali = new Credenziali(req.getCredential());
  1149.                 }
  1150.                 if(credenziali!=null && pddContext!=null){
  1151.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.CREDENZIALI_INVOCAZIONE, credenziali.toString());
  1152.                 }
  1153.             }catch(Throwable t){
  1154.                 // ignore
  1155.             }
  1156.                 
  1157.             
  1158.             try{
  1159.                 req.close();
  1160.             }catch(Exception e){
  1161.                 logCore.error("Request.close() error: "+e.getMessage(),e);
  1162.             }
  1163.         }
  1164.         
  1165.         // Imposto risposta

  1167.         Date dataPrimaSpedizioneRisposta = DateManager.getDate();
  1168.         Date dataRispostaSpedita = null; 
  1169.         Transazione transazioneDaAggiornare = null;
  1170.         
  1171.         if(context.getMsgDiagnostico()!=null){
  1172.             msgDiag = context.getMsgDiagnostico();
  1173.         }
  1174.         if(context.getResponseHeaders()==null) {
  1175.             context.setResponseHeaders(new HashMap<>());
  1176.         }
  1177.         ServicesUtils.setGovWayHeaderResponse(requestMessage!=null ? requestMessage.getServiceBinding() : requestInfo.getProtocolServiceBinding(),
  1178.                 responseMessage, openSPCoopProperties,
  1179.                 context.getResponseHeaders(), logCore, true, context.getPddContext(), requestInfo);
  1180.         if(context.getResponseHeaders()!=null){
  1181.             Iterator<String> keys = context.getResponseHeaders().keySet().iterator();
  1182.             while (keys.hasNext()) {
  1183.                 String key = (String) keys.next();
  1184.                 List<String> values = context.getResponseHeaders().get(key);
  1185.                 if(values!=null && !values.isEmpty()) {
  1186.                     for (int i = 0; i < values.size(); i++) {
  1187.                         String value = values.get(i);
  1188.                         String verbo = "";
  1189.                         try{
  1190.                             if(i==0) {
  1191.                                 verbo = "set";
  1192.                                 res.setHeader(key,value);
  1193.                             }
  1194.                             else {
  1195.                                 verbo = "add";
  1196.                                 res.addHeader(key,value);
  1197.                             }
  1198.                         }catch(Exception e){
  1199.                             logCore.error("Response."+verbo+"Header("+key+","+value+") error: "+e.getMessage(),e);
  1200.                         }   
  1201.                     }
  1202.                 }
  1203.             }   
  1204.         }
  1205.         if(context!=null && context.getProtocol()!=null){
  1206.             
  1207.             this.generatoreErrore.updateDominio(context.getIdentitaPdD());
  1208.         
  1209.             IDServizio idServizio = null;
  1210.             try{
  1211.                 idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(context.getProtocol().getTipoServizio(), 
  1212.                         context.getProtocol().getServizio(), 
  1213.                         context.getProtocol().getErogatore(), 
  1214.                         context.getProtocol().getVersioneServizio());
  1215.             }catch(Exception e){ 
  1216.                 // non dovrebbe succedere eccezione}
  1217.             }
  1218.             if(idServizio!=null){
  1219.                 idServizio.setAzione(context.getProtocol().getAzione());
  1220.                 this.generatoreErrore.updateInformazioniCooperazione(context.getProtocol().getFruitore(), idServizio);
  1221.             }
  1222.                             
  1223.             String servizioApplicativo = null;
  1224.             if(context.getIntegrazione()!=null){
  1225.                 servizioApplicativo = context.getIntegrazione().getServizioApplicativoFruitore();
  1226.             }
  1227.             this.generatoreErrore.updateInformazioniCooperazione(servizioApplicativo);
  1228.             
  1229.             this.generatoreErrore.updateProprietaErroreApplicativo(context.getProprietaErroreAppl());

  1231.         }
  1232.         DirectVMConnectorOutMessage vm = null;
  1233.         if(res instanceof DirectVMConnectorOutMessage){
  1234.             vm = (DirectVMConnectorOutMessage) res;
  1235.         }
  1236.         else if(req instanceof DumpRawConnectorOutMessage){
  1237.             if( ((DumpRawConnectorOutMessage)res).getWrappedConnectorOutMessage() instanceof DirectVMConnectorOutMessage ){
  1238.                 vm = (DirectVMConnectorOutMessage) ((DumpRawConnectorOutMessage)res).getWrappedConnectorOutMessage();
  1239.             }
  1240.         }
  1241.         if(vm!=null){
  1242.             if(context!=null && context.getPddContext()!=null){
  1243.                 DirectVMProtocolInfo pInfo = new DirectVMProtocolInfo();
  1244.                 Object oIdTransazione = context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  1245.                 if(oIdTransazione!=null){
  1246.                     pInfo.setIdTransazione((String)oIdTransazione);
  1247.                 }
  1248.                 if(context.getProtocol()!=null){
  1249.                     if(context.getProtocol().getIdRichiesta()!=null){
  1250.                         pInfo.setIdMessaggioRichiesta(context.getProtocol().getIdRichiesta());
  1251.                     }
  1252.                     if(context.getProtocol().getIdRisposta()!=null){
  1253.                         pInfo.setIdMessaggioRisposta(context.getProtocol().getIdRisposta());
  1254.                     }
  1255.                 }
  1256.                 vm.setDirectVMProtocolInfo(pInfo);
  1257.             }
  1258.         }
  1259.         
  1260.         InformazioniErroriInfrastrutturali informazioniErrori = ServicesUtils.readInformazioniErroriInfrastrutturali(pddContext);
  1261.         
  1262.         OpenSPCoop2Message responseMessageError = null;
  1263.         EsitoTransazione esito = null;
  1264.         String descrizioneSoapFault = "";
  1265.         int statoServletResponse = 200;
  1266.         Throwable erroreConsegnaRisposta = null;
  1267.         boolean httpEmptyResponse = false;
  1268.         boolean erroreConnessioneClient = false;
  1269.         boolean erroreResponseTimeout = false;
  1270.         boolean erroreResponsePayloadTooLarge = false;
  1271.         boolean sendInvoked = false;
  1272.         boolean registraTracciaOutResponse = false;
  1273.         try{
  1274.             if(responseMessage!=null && !responseMessage.isForcedEmptyResponse() && (responseMessage.getForcedResponse()==null)){
  1275.                     
  1276.                 // force response code
  1277.                 if(responseMessage.getForcedResponseCode()!=null){
  1278.                     try{
  1279.                         statoServletResponse = Integer.parseInt(responseMessage.getForcedResponseCode());
  1280.                     }catch(Exception e){
  1281.                         // ignore
  1282.                     }
  1283.                 }
  1284.                                 
  1285.                 // transfer length
  1286.                 ServicesUtils.setTransferLength(openSPCoopProperties.getTransferLengthModes_ricezioneContenutiApplicativi(), 
  1287.                         req, res, responseMessage);
  1288.                 
  1289.                 // content type
  1290.                 // Alcune implementazioni richiedono di aggiornare il Content-Type
  1291.                 responseMessage.updateContentType();
  1292.                 ServicesUtils.setContentType(responseMessage, res);
  1293.                 
  1294.                 // http status
  1295.                 boolean consume = true;
  1296.                 if(ServiceBinding.SOAP.equals(responseMessage.getServiceBinding()) ){
  1297.                     //SOAPBody body = responseMessage.castAsSoap().getSOAPBody();
  1298.                     OpenSPCoop2SoapMessage soapMessage = responseMessage.castAsSoap();
  1299.                     if(soapMessage.hasSOAPFault()){
  1300.                         consume = false; // può essere usato nel post out response handler
  1301.                         statoServletResponse = 500;
  1302.                         descrizioneSoapFault = " ("+SoapUtils.safe_toString(responseMessage.getFactory(), soapMessage.getSOAPBody().getFault(), false, logCore)+")";
  1303.                     }
  1304.                     else if(statoServletResponse==500) {
  1305.                         // in SOAP 500 deve essere associato con un fault
  1306.                         if(!soapMessage.isSOAPBodyEmpty()) {
  1307.                             statoServletResponse = 200;
  1308.                         }
  1309.                         else {
  1310.                             statoServletResponse = protocolFactory.createProtocolManager().getHttpReturnCodeEmptyResponseOneWay();
  1311.                         }
  1312.                     }
  1313.                 }
  1314.                 else if(responseMessage.castAsRest().isProblemDetailsForHttpApis_RFC7807() || 
  1315.                         (MessageRole.FAULT.equals(responseMessage.getMessageRole()) &&
  1316.                             (
  1317.                             MessageType.XML.equals(responseMessage.getMessageType()) 
  1318.                                     || 
  1319.                             MessageType.JSON.equals(responseMessage.getMessageType())
  1320.                             )
  1321.                         )
  1322.                     ) {
  1323.                     consume = false; // può essere usato nel post out response handler
  1324.                     String contentAsString = null;
  1325.                     try {
  1326.                         contentAsString = responseMessage.castAsRest().getContentAsString();
  1327.                     }catch(Throwable t) {
  1328.                         logCore.error("Parsing errore non riuscito: "+t.getMessage(),t);
  1329.                     }
  1330.                     if(contentAsString!=null && StringUtils.isNotEmpty(contentAsString)) {
  1331.                         descrizioneSoapFault = " ("+contentAsString+")";
  1332.                     }
  1333.                 }
  1334.                 res.setStatus(statoServletResponse);
  1335.                 
  1336.                 // esito calcolato prima del sendResponse, per non consumare il messaggio
  1337.                 esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(), 
  1338.                         statoServletResponse, requestInfo.getIntegrationServiceBinding(),
  1339.                         responseMessage, context.getProprietaErroreAppl(), informazioniErrori,
  1340.                         pddContext);
  1341.                 
  1342.                 // se il tracciamento lo prevedo emetto un log
  1343.                 registraTracciaOutResponse = true;
  1344.                 transazioneDaAggiornare = registraTracciaOutResponse(context, postOutResponseContext,
  1345.                         dataAccettazioneRichiesta, dataIngressoRichiesta,
  1346.                         dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1347.                         esito, statoServletResponse,
  1348.                         idModulo, req, requestMessage, 
  1349.                         responseMessage, erroreConsegnaRisposta, responseMessageError,
  1350.                         msgDiag);
  1351.                 
  1352.                 // contenuto
  1353.                 Utilities.printFreeMemory("RicezioneContenutiApplicativiDirect - Pre scrittura risposta");
  1354.                 
  1355.                 // Il contentLenght, nel caso di TransferLengthModes.CONTENT_LENGTH e' gia' stato calcolato
  1356.                 // con una writeTo senza consume. Riuso il solito metodo per evitare differenze di serializzazione
  1357.                 // e cambiare quindi il content length effettivo.
  1358.                 sendInvoked = true;
  1359.                 if(TransferLengthModes.CONTENT_LENGTH.equals(openSPCoopProperties.getTransferLengthModes_ricezioneContenutiApplicativi())){
  1360.                     res.sendResponse(responseMessage, false);
  1361.                 } else {
  1362.                     res.sendResponse(responseMessage, consume);
  1363.                 }
  1364.                 Utilities.printFreeMemory("RicezioneContenutiApplicativiDirect - Post scrittura risposta");


  1367.             }
  1368.             
  1369.             else if(responseMessage!=null && responseMessage.getForcedResponse()!=null) {
  1370.                 byte[]response = responseMessage.getForcedResponse().getContent();
  1371. //              if(response==null) {
  1372. //                  throw new Exception("Trovata configurazione 'forcedResponse' senza una vera risposta");
  1373. //              }
  1374.             
  1375.                 if(response!=null && response.length<1024) {
  1376.                     // Se il messaggio non è troppo grande lo aggiungo al diagnostico
  1377.                     try {
  1378.                         descrizioneSoapFault = "("+new String(response)+")";
  1379.                     }catch(Throwable t) {
  1380.                         descrizioneSoapFault = "";
  1381.                     }
  1382.                 }
  1383.                 
  1384.                 if(responseMessage.getForcedResponse().getHeadersValues()!=null &&
  1385.                         responseMessage.getForcedResponse().getHeadersValues().size()>0) {
  1386.                     Iterator<String> keys = responseMessage.getForcedResponse().getHeadersValues().keySet().iterator();
  1387.                     while (keys.hasNext()) {
  1388.                         String key = (String) keys.next();
  1389.                         List<String> values = responseMessage.getForcedResponse().getHeadersValues().get(key);
  1390.                         if(values!=null && !values.isEmpty()) {
  1391.                             for (int i = 0; i < values.size(); i++) {
  1392.                                 String value = values.get(i);
  1393.                                 String verbo = "";
  1394.                                 try{
  1395.                                     if(i==0) {
  1396.                                         verbo = "set";
  1397.                                         res.setHeader(key,value);
  1398.                                     }
  1399.                                     else {
  1400.                                         verbo = "add";
  1401.                                         res.addHeader(key,value);
  1402.                                     }
  1403.                                 }catch(Exception e){
  1404.                                     logCore.error("Response(Forced)."+verbo+"Header("+key+","+value+") error: "+e.getMessage(),e);
  1405.                                 }   
  1406.                             }
  1407.                         }
  1408.                     }   
  1409.                 }
  1410.                 
  1411.                 if(responseMessage.getForcedResponse().getContentType()!=null) {
  1412.                     res.setContentType(responseMessage.getForcedResponse().getContentType());
  1413.                 }
  1414.                 
  1415.                 if(responseMessage.getForcedResponse().getResponseCode()!=null) {
  1416.                     try{
  1417.                         statoServletResponse = Integer.parseInt(responseMessage.getForcedResponse().getResponseCode());
  1418.                     }catch(Exception e){
  1419.                         // ignore
  1420.                     }
  1421.                 }
  1422.                 else if(responseMessage!=null && responseMessage.getForcedResponseCode()!=null) {
  1423.                     try{
  1424.                         statoServletResponse = Integer.parseInt(responseMessage.getForcedResponseCode());
  1425.                     }catch(Exception e){
  1426.                         // ignore
  1427.                     }
  1428.                 }
  1429.                 res.setStatus(statoServletResponse);
  1430.                 
  1431.                 // esito calcolato prima del sendResponse, per non consumare il messaggio
  1432.                 esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(), 
  1433.                         statoServletResponse, requestInfo.getIntegrationServiceBinding(),
  1434.                         responseMessage, context.getProprietaErroreAppl(),informazioniErrori,
  1435.                         pddContext);
  1436.                 
  1437.                 // se il tracciamento lo prevedo emetto un log
  1438.                 registraTracciaOutResponse = true;
  1439.                 transazioneDaAggiornare = registraTracciaOutResponse(context, postOutResponseContext,
  1440.                         dataAccettazioneRichiesta, dataIngressoRichiesta,
  1441.                         dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1442.                         esito, statoServletResponse,
  1443.                         idModulo, req, requestMessage, 
  1444.                         responseMessage, erroreConsegnaRisposta, responseMessageError,
  1445.                         msgDiag);
  1446.                 
  1447.                 if(response!=null) {
  1448.                     sendInvoked = true;
  1449.                     res.sendResponse(DumpByteArrayOutputStream.newInstance(response));
  1450.                 }
  1451.                 
  1452.             }
  1453.             else{
  1454.                 if(responseMessage!=null && responseMessage.getForcedResponseCode()!=null) {
  1455.                     try{
  1456.                         statoServletResponse = Integer.parseInt(responseMessage.getForcedResponseCode());
  1457.                     }catch(Exception e){
  1458.                         // ignore
  1459.                     }
  1460.                 }
  1461.                 else {
  1462.                     statoServletResponse = protocolFactory.createProtocolManager().getHttpReturnCodeEmptyResponseOneWay();
  1463.                 }
  1464.                 res.setStatus(statoServletResponse);
  1465.                 httpEmptyResponse = true;
  1466.                 
  1467.                 // carico-vuoto gestito all'interno
  1468.                 esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(), 
  1469.                         statoServletResponse, requestInfo.getIntegrationServiceBinding(),
  1470.                         responseMessage, context.getProprietaErroreAppl(), informazioniErrori,
  1471.                         pddContext);
  1472.                 
  1473.                 // se il tracciamento lo prevedo emetto un log
  1474.                 registraTracciaOutResponse = true;
  1475.                 transazioneDaAggiornare = registraTracciaOutResponse(context, postOutResponseContext,
  1476.                         dataAccettazioneRichiesta, dataIngressoRichiesta,
  1477.                         dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1478.                         esito, statoServletResponse,
  1479.                         idModulo, req, requestMessage, 
  1480.                         responseMessage, erroreConsegnaRisposta, responseMessageError,
  1481.                         msgDiag);

  1483.             }
  1484.         }catch(Throwable e){            
  1485.             logCore.error("ErroreGenerale",e);
  1486.             erroreConsegnaRisposta = e;
  1487.                         
  1488.             erroreConnessioneClient = ServicesUtils.isConnessioneClientNonDisponibile(e);
  1489.             if(!erroreConnessioneClient && ServicesUtils.isConnessioneServerReadTimeout(e)) {
  1490.                 erroreResponseTimeout = true; // non e' stato possibile consegnare tutta la risposta. Il client ha ricevuto 200 ma non ha ricevuto la risposta per intero
  1491.                 erroreConsegnaRisposta = new CoreException("Connessione con il backend dell'API non più disponibile: "+e.getMessage(),e);
  1492.             }
  1493.             if(!erroreConnessioneClient && !erroreResponseTimeout && ServicesUtils.isResponsePayloadTooLarge(e)) {
  1494.                 erroreResponsePayloadTooLarge = true;  // non e' stato possibile consegnare tutta la risposta. Il client ha ricevuto 200 ma non ha ricevuto la risposta per intero
  1495.                 erroreConsegnaRisposta = new CoreException("Risposta ricevuta dal backend dell'API non gestibile: "+e.getMessage(),e);
  1496.             }
  1497.             
  1498.             // Genero risposta con errore
  1499.             try{
  1500.                 if(sendInvoked==false) {
  1501.                     // nel caso sia già stato inoltrata una risposta non e' più possibile modificarlo cosi come tutti gli header etc... 
  1502.                     InformazioniErroriInfrastrutturali informazioniErrori_error = new InformazioniErroriInfrastrutturali();
  1503.                     if( (responseMessage!=null && responseMessage.getParseException() != null) ||
  1504.                             (pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION))){
  1505.                         informazioniErrori_error.setContenutoRispostaNonRiconosciuto(true);
  1506.                         ParseException parseException = null;
  1507.                         if( responseMessage!=null && responseMessage.getParseException() != null ){
  1508.                             parseException = responseMessage.getParseException();
  1509.                         }
  1510.                         else{
  1511.                             parseException = (ParseException) pddContext.getObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  1512.                         }
  1513.                         String msgErrore = parseException.getParseException().getMessage();
  1514.                         if(msgErrore==null){
  1515.                             msgErrore = parseException.getParseException().toString();
  1516.                         }
  1517.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  1518.                         logCore.error("parsingExceptionRisposta",parseException.getSourceException());
  1519.                         msgDiag.logPersonalizzato("parsingExceptionRisposta");
  1520.                         responseMessageError = this.generatoreErrore.build(pddContext, IntegrationFunctionError.UNPROCESSABLE_RESPONSE_CONTENT,
  1521.                                 ErroriIntegrazione.ERRORE_440_PARSING_EXCEPTION_RISPOSTA.
  1522.                                 getErrore440_MessaggioRispostaMalformato(parseException.getParseException()),
  1523.                                 parseException.getParseException(),null);
  1524.                     } else{
  1525.                         IntegrationFunctionError ife = IntegrationFunctionError.INTERNAL_RESPONSE_ERROR;
  1526.                         if(e instanceof HandlerException) {
  1527.                             HandlerException he = (HandlerException) e;
  1528.                             if(he.getIntegrationFunctionError()!=null) {
  1529.                                 ife = he.getIntegrationFunctionError();
  1530.                             }
  1531.                         }
  1532.                         responseMessageError = this.generatoreErrore.build(pddContext, ife,
  1533.                                 ErroriIntegrazione.ERRORE_426_SERVLET_ERROR.
  1534.                                 getErrore426_ServletError(false, e),
  1535.                                 e,null);
  1536.                     }
  1537.                     
  1538.                     // transfer length
  1539.                     ServicesUtils.setTransferLength(openSPCoopProperties.getTransferLengthModes_ricezioneContenutiApplicativi(), 
  1540.                             req, res, responseMessageError);
  1541.                     
  1542.                     // content type
  1543.                     ServicesUtils.setContentType(responseMessageError, res);
  1544.                     
  1545.                     // http status
  1546.                     if(responseMessageError!=null && responseMessageError.getForcedResponseCode()!=null) {
  1547.                         try{
  1548.                             statoServletResponse = Integer.parseInt(responseMessageError.getForcedResponseCode());
  1549.                             res.setStatus(statoServletResponse);
  1550.                         }catch(Exception eStatus){
  1551.                             // ignore
  1552.                         }
  1553.                     }
  1554.                     if(responseMessageError!=null && ServiceBinding.SOAP.equals(responseMessageError.getServiceBinding()) ){
  1555.                         SOAPBody body = responseMessageError.castAsSoap().getSOAPBody();
  1556.                         if(body!=null && body.hasFault()){
  1557.                             statoServletResponse = 500;
  1558.                             res.setStatus(statoServletResponse);
  1559.                             descrizioneSoapFault = " ("+SoapUtils.safe_toString(responseMessageError.getFactory(), body.getFault(), false, logCore)+")";
  1560.                         }
  1561.                     }
  1562.                     
  1563.                     // esito calcolato prima del sendResponse, per non consumare il messaggio
  1564.                     esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(),
  1565.                             statoServletResponse, requestInfo.getIntegrationServiceBinding(),
  1566.                             responseMessageError, context.getProprietaErroreAppl(), informazioniErrori_error,
  1567.                             pddContext);
  1568.                     
  1569.                     // se il tracciamento lo prevedo emetto un log
  1570.                     // se ho già provato prima a tracciare non lo faccio un'altra volta
  1571.                     if(!registraTracciaOutResponse) {
  1572.                         transazioneDaAggiornare = registraTracciaOutResponse(context, postOutResponseContext,
  1573.                             dataAccettazioneRichiesta, dataIngressoRichiesta,
  1574.                             dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1575.                             esito, statoServletResponse,
  1576.                             idModulo, req, requestMessage, 
  1577.                             responseMessage, erroreConsegnaRisposta, responseMessageError,
  1578.                             msgDiag);
  1579.                     }
  1580.                     
  1581.                     // contenuto
  1582.                     // Il contentLenght, nel caso di TransferLengthModes.CONTENT_LENGTH e' gia' stato calcolato
  1583.                     // con una writeTo senza consume. Riuso il solito metodo per evitare differenze di serializzazione
  1584.                     // e cambiare quindi il content length effettivo.
  1585.                     //if(TransferLengthModes.CONTENT_LENGTH.equals(openSPCoopProperties.getTransferLengthModes_ricezioneContenutiApplicativi())){
  1586.                     //  res.sendResponse(responseMessageError, false);
  1587.                     //} else {
  1588.                         //res.sendResponse(responseMessageError, true);
  1589.                         res.sendResponse(responseMessageError, false); // può essere usato nel post out response handler
  1590.                     //}
  1591.                 }
  1592.                                                                 
  1593.             }catch(Throwable error){
  1594.                 
  1595.                 if(!erroreConnessioneClient){
  1596.                     erroreConnessioneClient = ServicesUtils.isConnessioneClientNonDisponibile(error);
  1597.                 }
  1598.                 
  1599.                 logCore.error("Generazione di un risposta errore non riuscita",error);
  1600.                 statoServletResponse = 500;
  1601.                 try{
  1602.                     IntegrationFunctionError ife = null;
  1603.                     if(error instanceof HandlerException) {
  1604.                         HandlerException he = (HandlerException) error;
  1605.                         if(he.getIntegrationFunctionError()!=null) {
  1606.                             ife = he.getIntegrationFunctionError();
  1607.                         }
  1608.                     }
  1609.                     if(ife!=null) {
  1610.                         responseMessageError = this.generatoreErrore.buildFault(error, pddContext, ife);
  1611.                     }else {
  1612.                         responseMessageError = this.generatoreErrore.buildFault(error, pddContext);
  1613.                     }
  1614.                     if(responseMessageError!=null && responseMessageError.getForcedResponseCode()!=null) {
  1615.                         try{
  1616.                             statoServletResponse = Integer.parseInt(responseMessageError.getForcedResponseCode());
  1617.                         }catch(Exception eStatus){
  1618.                             // ignore
  1619.                         }
  1620.                     }
  1621.                     
  1622.                     try{
  1623.                         res.setStatus(statoServletResponse);
  1624.                     }catch(Exception eStatus){
  1625.                         logCore.error("Response.setStatus("+statoServletResponse+") error: "+eStatus.getMessage(),eStatus);
  1626.                     }
  1627.                     
  1628.                     res.sendResponse(responseMessageError, false); // può essere usato nel post out response handler
  1629.                 }catch(Throwable  eError){
  1630.                     if(!erroreConnessioneClient){
  1631.                         erroreConnessioneClient = ServicesUtils.isConnessioneClientNonDisponibile(eError);
  1632.                     }
  1633.                     try {
  1634.                         res.setStatus(statoServletResponse);
  1635.                     }catch(Throwable t) {
  1636.                         // ignore
  1637.                     }
  1638.                     try{
  1639.                         res.sendResponse(DumpByteArrayOutputStream.newInstance(error.toString().getBytes()));
  1640.                     }catch(Exception erroreStreamChiuso){ 
  1641.                         erroreConnessioneClient = true;
  1642.                         //se lo stream non e' piu' disponibile non si potra' consegnare alcuna risposta
  1643.                     }
  1644.                 }
  1645.                 try{
  1646.                     esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(),EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX);
  1647.                 }catch(Exception eBuildError){
  1648.                     esito = EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  1649.                 }
  1650.             }
  1651.             
  1652.         }finally{
  1653.                         
  1654.             if(sendInvoked==false) {
  1655.                 // nel caso sia già stato inoltrata una risposta non e' più possibile modificarlo cosi come tutti gli header etc...
  1656.                 statoServletResponse = res.getResponseStatus(); // puo' essere "trasformato" da api engine
  1657.             }
  1658.             msgDiag.addKeyword(CostantiPdD.KEY_CODICE_CONSEGNA, ""+statoServletResponse);
  1659.             msgDiag.addKeyword(CostantiPdD.KEY_SOAP_FAULT, descrizioneSoapFault);
  1660.             
  1661.             try{

  1663.                 // Flush and close response
  1664.                 // NOTA: per poter ottenere l'errore di BrokenPipe sempre, deve essere disabilitato il socketBufferOutput sul servlet container.
  1665.                 // Se non lo si disabilta, l'errore viene ritornato solo se il messaggio supera la dimensione del buffer (default: 8192K)
  1666.                 // Ad esempio in tomcat utilizzare (socketBuffer="-1"): 
  1667.                 //    <Connector protocol="HTTP/1.1" port="8080" address="${jboss.bind.address}" 
  1668.                 //       connectionTimeout="20000" redirectPort="8443" socketBuffer="-1" />
  1669.                 res.flush(true);
  1670.                 res.close(true);
  1671.                 
  1672.                 dataRispostaSpedita = DateManager.getDate();
  1673.                 
  1674.                 // Emetto diagnostico
  1675.                 if(erroreConsegnaRisposta!=null){
  1676.                     
  1677.                     // Risposta non ritornata al servizio applicativo, il socket verso il servizio applicativo era chiuso o cmq inutilizzabile
  1678.                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_CONSEGNA, erroreConsegnaRisposta.toString()); // NOTA: lasciare e.toString()
  1679.                     msgDiag.logPersonalizzato("consegnaRispostaApplicativaFallita");
  1680.                     
  1681.                 }else{
  1682.                     if(httpEmptyResponse){
  1683.                         msgDiag.logPersonalizzato("consegnaRispostaApplicativaVuota");
  1684.                     }else{
  1685.                         if(statoServletResponse>=300)
  1686.                             msgDiag.logPersonalizzato("consegnaRispostaApplicativaKoEffettuata");
  1687.                         else
  1688.                             msgDiag.logPersonalizzato("consegnaRispostaApplicativaOkEffettuata");
  1689.                     }
  1690.                 }
  1691.                 
  1692.             }catch(Exception e){
  1693.                 
  1694.                 erroreConnessioneClient = true;
  1695.                 
  1696.                 logCore.error("Chiusura stream non riuscita",e);
  1697.                 
  1698.                 // Risposta non ritornata al servizio applicativo, il socket verso il servizio applicativo era chiuso o cmq inutilizzabile
  1699.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_CONSEGNA, e.toString()); // NOTA: lasciare e.toString()
  1700.                 
  1701.                 msgDiag.logPersonalizzato("consegnaRispostaApplicativaFallita");
  1702.                 
  1703.                 erroreConsegnaRisposta = e;
  1704.                 
  1705.                 if(esito!=null){
  1706.                     if(EsitoTransazioneName.OK.equals(esito.getName())){
  1707.                         // non è ok, essendo andato in errore il flush
  1708.                         try{
  1709.                             esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(),EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX);
  1710.                         }catch(Exception eBuildError){
  1711.                             esito = EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  1712.                         }
  1713.                     }
  1714.                 }
  1715.                 else{
  1716.                     // non dovrebbe mai essere null
  1717.                 }
  1718.                 
  1719.             } finally {
  1720.                 if(dataRispostaSpedita==null) {
  1721.                     dataRispostaSpedita = DateManager.getDate();
  1722.                 }
  1723.             }
  1724.             
  1725.             if(dumpRaw!=null && dumpRaw.isActiveDumpRisposta()){
  1726.                 dumpRaw.serializeResponse(((DumpRawConnectorOutMessage)res));
  1727.             }
  1728.         }
  1729.         
  1730.         if(erroreConnessioneClient){
  1731.             // forzo esito errore connessione client
  1732.             try{
  1733.                 esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(),EsitoTransazioneName.ERRORE_CONNESSIONE_CLIENT_NON_DISPONIBILE);
  1734.             }catch(Exception eBuildError){
  1735.                 esito = EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  1736.             }
  1737.         }
  1738.         else if(erroreResponseTimeout){
  1739.             // forzo esito errore response timeout
  1740.             try{
  1741.                 esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(),EsitoTransazioneName.ERRORE_RESPONSE_TIMEOUT);
  1742.             }catch(Exception eBuildError){
  1743.                 esito = EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  1744.             }
  1745.         }
  1746.         else if(erroreResponsePayloadTooLarge){
  1747.             // forzo esito errore dovuto alla policy di rate limiting
  1748.             try{
  1749.                 esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(),EsitoTransazioneName.CONTROLLO_TRAFFICO_POLICY_VIOLATA);
  1750.             }catch(Exception eBuildError){
  1751.                 esito = EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  1752.             }
  1753.         }
  1754.         else if(EsitoTransazioneName.OK.equals(esito.getName()) && context!=null && context.getPddContext()!=null && context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.EMESSI_DIAGNOSTICI_ERRORE)) {
  1755.             // caso di errore generato durante il tracciamento dopo aver calcolato l'esito, in cui non viene sollevata una eccezione
  1756.             esito = ServicesUtils.updateEsitoConAnomalie(esito, logCore, protocolFactory);
  1757.         }
  1758.         
  1759.         
  1760.         
  1761.         
  1762.         
  1763.         
  1764.         // *** Chiudo connessione verso PdD Destinazione per casi stateless ***
  1765.         String location = "...";
  1766.         try{
  1767.             IConnettore c = null;
  1768.             if(context!=null && context.getPddContext()!=null && context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) {
  1769.                 idTransazione = (String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  1770.             }
  1771.             if(idTransazione!=null) {
  1772.             //if(context.getIdMessage()!=null){
  1773.                 c = RepositoryConnettori.removeConnettorePD(
  1774.                         //context.getIdMessage()
  1775.                         idTransazione
  1776.                         );
  1777.             }
  1778.             if(c!=null){
  1779.                 location = c.getLocation();
  1780.                 c.disconnect();
  1781.             }
  1782.         }catch(Exception e){
  1783.             msgDiag.logDisconnectError(e, location);
  1784.         }
  1785.         
  1786.         

  1788.         
  1789.         
  1790.         
  1791.         
  1792.         
  1793.         
  1794.         
  1795.         /* ------------  PostOutResponseHandler ------------- */
  1796.         
  1797.         if(postOutResponseContext!=null){
  1798.             try {
  1799.                 updateContext(context, postOutResponseContext,
  1800.                         dataAccettazioneRichiesta, dataIngressoRichiesta,
  1801.                         dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1802.                         esito, statoServletResponse,
  1803.                         idModulo, req, requestMessage, 
  1804.                         responseMessage, erroreConsegnaRisposta, responseMessageError);
  1805.                 postOutResponseContext.setTransazioneDaAggiornare(transazioneDaAggiornare);
  1806.             }catch(Exception e){
  1807.                 msgDiag.logErroreGenerico(e,"postOutResponse, preparazione contesto");
  1808.             }

  1810.             GestoreHandlers.postOutResponse(postOutResponseContext, msgDiag, logCore);
  1811.         }
  1812.         
  1813.         
  1814.         
  1815.         
  1816.         
  1817.         
  1818.         
  1819.         
  1820.         
  1821.         
  1822.         // *** Rilascio risorse NotifierInputStream ***
  1823.         
  1824.         // request
  1825.         try{
  1826.             if(requestMessage!=null && requestMessage.getNotifierInputStream()!=null){
  1827.                 requestMessage.getNotifierInputStream().close();
  1828.             }
  1829.         }catch(Exception e){
  1830.             msgDiag.logErroreGenerico(e,"Rilascio risorse NotifierInputStream richiesta");
  1831.         }
  1832.         
  1833.         // response
  1834.         try{
  1835.             if(responseMessage!=null && responseMessage.getNotifierInputStream()!=null){
  1836.                 responseMessage.getNotifierInputStream().close();
  1837.             }
  1838.         }catch(Exception e){
  1839.             msgDiag.logErroreGenerico(e,"Rilascio risorse NotifierInputStream risposta");
  1840.         }
  1841.         
  1842.         
  1843.         
  1844.         
  1845.         
  1846.         
  1847.         
  1848.         
  1849.         
  1850.         // *** GB ***
  1851.         requestMessage = null;
  1852.         responseMessage = null;
  1853.         responseMessageError = null;
  1854.         // *** GB ***
  1855.         
  1856.         return;

  1858.     }
  1859.     
  1860.     
  1861.     private void updateContext(RicezioneContenutiApplicativiContext context, PostOutResponseContext postOutResponseContext,
  1862.             Date dataAccettazioneRichiesta, Date dataIngressoRichiesta,
  1863.             Date dataPrimaSpedizioneRisposta, Date dataRispostaSpedita,
  1864.             EsitoTransazione esito, int statoServletResponse,
  1865.             String idModulo, ConnectorInMessage req, OpenSPCoop2Message requestMessage, 
  1866.             OpenSPCoop2Message responseMessage, Throwable erroreConsegnaRisposta, OpenSPCoop2Message responseMessageError) throws ConnectorException {
  1867.         if(postOutResponseContext!=null){
  1868.             postOutResponseContext.getPddContext().addObject(CostantiPdD.DATA_ACCETTAZIONE_RICHIESTA, dataAccettazioneRichiesta);
  1869.             if(dataIngressoRichiesta!=null){
  1870.                 postOutResponseContext.getPddContext().addObject(CostantiPdD.DATA_INGRESSO_RICHIESTA, dataIngressoRichiesta);
  1871.             }
  1872.             postOutResponseContext.setDataElaborazioneMessaggio(DateManager.getDate());
  1873.             postOutResponseContext.setDataPrimaSpedizioneRisposta(dataPrimaSpedizioneRisposta);
  1874.             postOutResponseContext.setDataRispostaSpedita(dataRispostaSpedita);
  1875.             postOutResponseContext.setEsito(esito);
  1876.             postOutResponseContext.setReturnCode(statoServletResponse);
  1877.             postOutResponseContext.setResponseHeaders(context.getResponseHeaders());
  1878.             postOutResponseContext.setProtocollo(context.getProtocol());
  1879.             postOutResponseContext.setIntegrazione(context.getIntegrazione());
  1880.             if(context.getTipoPorta()!=null)
  1881.                 postOutResponseContext.setTipoPorta(context.getTipoPorta());    
  1882.             postOutResponseContext.setIdModulo(idModulo);
  1883.             
  1884.             if(requestMessage!=null){
  1885.                 long incomingRequestMessageContentLength = requestMessage.getIncomingMessageContentLength();
  1886.                 long outgoingRequestMessageContentLenght = requestMessage.getOutgoingMessageContentLength();
  1887.                 if(incomingRequestMessageContentLength<0){
  1888.                     int cl = req.getContentLength();
  1889.                     if(cl>0){
  1890.                         /**System.out.println("HTTP");*/
  1891.                         incomingRequestMessageContentLength = cl + 0l;
  1892.                     }
  1893.                     else{
  1894.                         /**System.out.println("FLUSH");*/
  1895.                         // forzo la lettura del messaggio per impostare la dimensione della richiesta
  1896.                         try{
  1897.                             requestMessage.writeTo(NullOutputStream.INSTANCE, true);
  1898.                         }catch(Exception eFlush){
  1899.                             // ignore
  1900.                         }
  1901.                         incomingRequestMessageContentLength = requestMessage.getIncomingMessageContentLength();
  1902.                     }
  1903.                 }
  1904.                 postOutResponseContext.setInputRequestMessageSize(incomingRequestMessageContentLength);
  1905.                 postOutResponseContext.setOutputRequestMessageSize(outgoingRequestMessageContentLenght);
  1906.             }else{
  1907.                 postOutResponseContext.setInputRequestMessageSize(req.getContentLength()+0l);
  1908.             }
  1909.             
  1910.             if(erroreConsegnaRisposta!=null){
  1911.                 if(responseMessageError!=null){
  1912.                     postOutResponseContext.setInputResponseMessageSize(responseMessageError.getIncomingMessageContentLength());
  1913.                     postOutResponseContext.setOutputResponseMessageSize(responseMessageError.getOutgoingMessageContentLength());
  1914.                     postOutResponseContext.setMessaggio(responseMessageError);
  1915.                 }else{
  1916.                     if(responseMessage!=null && !responseMessage.isForcedEmptyResponse() && responseMessage.getForcedResponse()==null){
  1917.                         postOutResponseContext.setInputResponseMessageSize(responseMessage.getIncomingMessageContentLength());
  1918.                         postOutResponseContext.setOutputResponseMessageSize(responseMessage.getOutgoingMessageContentLength());
  1919.                         postOutResponseContext.setMessaggio(responseMessage);
  1920.                     }
  1921.                 }
  1922.                 postOutResponseContext.setErroreConsegna(erroreConsegnaRisposta.toString()); // NOTA: lasciare e.toString()
  1923.             }
  1924.             else if(responseMessage!=null && !responseMessage.isForcedEmptyResponse() && responseMessage.getForcedResponse()==null){
  1925.                 postOutResponseContext.setInputResponseMessageSize(responseMessage.getIncomingMessageContentLength());
  1926.                 postOutResponseContext.setOutputResponseMessageSize(responseMessage.getOutgoingMessageContentLength());
  1927.                 postOutResponseContext.setMessaggio(responseMessage);
  1928.             }
  1929.             else if(responseMessage!=null && responseMessage.getForcedResponse()!=null &&
  1930.                     responseMessage.getForcedResponse().getContent()!=null) {
  1931.                 postOutResponseContext.setInputResponseMessageSize(responseMessage.getIncomingMessageContentLength());
  1932.                 postOutResponseContext.setOutputResponseMessageSize((long) responseMessage.getForcedResponse().getContent().length);
  1933.             }                   
  1934.         }
  1935.     }

  1937.     private Transazione registraTracciaOutResponse(RicezioneContenutiApplicativiContext context, PostOutResponseContext postOutResponseContext,
  1938.             Date dataAccettazioneRichiesta, Date dataIngressoRichiesta,
  1939.             Date dataPrimaSpedizioneRisposta, Date dataRispostaSpedita,
  1940.             EsitoTransazione esito, int statoServletResponse,
  1941.             String idModulo, ConnectorInMessage req, OpenSPCoop2Message requestMessage, 
  1942.             OpenSPCoop2Message responseMessage, Throwable erroreConsegnaRisposta, OpenSPCoop2Message responseMessageError, 
  1943.             MsgDiagnostico msgDiag) throws HandlerException {

  1945.         try {
  1946.         
  1947.             if(postOutResponseContext!=null) {
  1948.                 updateContext(context, postOutResponseContext,
  1949.                         dataAccettazioneRichiesta, dataIngressoRichiesta,
  1950.                         dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1951.                         esito, statoServletResponse,
  1952.                         idModulo, req, requestMessage, 
  1953.                         responseMessage, erroreConsegnaRisposta, responseMessageError);
  1954.                 
  1955.                 TracciamentoManager tracciamentoManager = new TracciamentoManager(FaseTracciamento.OUT_RESPONSE);
  1956.                 if(!tracciamentoManager.isTransazioniEnabled()) {
  1957.                     return null;
  1958.                 }
  1959.                 
  1960.                 InformazioniTransazione info = new InformazioniTransazione(postOutResponseContext);
  1961.                 
  1962.                 tracciamentoManager.invoke(info, postOutResponseContext.getEsito(), context.getResponseHeaders(), msgDiag);
  1963.                 
  1964.                 return info.getTransazioneDaAggiornare();
  1965.             }
  1966.             
  1967.         }catch(Exception e) {
  1968.             ServicesUtils.processTrackingException(e, postOutResponseContext.getLogCore(), FaseTracciamento.OUT_RESPONSE, context.getPddContext());
  1969.         }
  1970.         
  1971.         return null;
  1972.     }
  1973.     
  1974.     private void registraTracciaInRequest(RicezioneContenutiApplicativiContext context, 
  1975.             IProtocolFactory<?> protocolFactory, Logger log, MsgDiagnostico msgDiag) throws HandlerException {

  1977.         try {
  1978.             TracciamentoManager tracciamentoManager = new TracciamentoManager(FaseTracciamento.IN_REQUEST);
  1979.             if(!tracciamentoManager.isTransazioniEnabled()) {
  1980.                 return;
  1981.             }
  1982.                 
  1983.             InformazioniTransazione info = new InformazioniTransazione();
  1984.             info.setContext(context.getPddContext());
  1985.             info.setTipoPorta(context.getTipoPorta());
  1986.             info.setProtocolFactory(protocolFactory);
  1987.             info.setProtocollo(context.getProtocol());
  1988.             info.setIntegrazione(context.getIntegrazione());
  1989.             info.setIdModulo(context.getIdModulo());
  1990.             
  1991.             TransportRequestContext transportRequestContext = null;
  1992.             if(context.getMessageRequest()!=null) {
  1993.                 transportRequestContext = context.getMessageRequest().getTransportRequestContext();
  1994.             }
  1995.             String esitoContext = EsitoBuilder.getTipoContext(transportRequestContext, EsitiProperties.getInstance(log, protocolFactory), log);
  1996.             
  1997.             tracciamentoManager.invoke(info, esitoContext, msgDiag);
  1998.         }catch(Exception e) {
  1999.             ServicesUtils.processTrackingException(e, log, FaseTracciamento.IN_REQUEST, context.getPddContext());
  2000.         }
  2001.         
  2002.     }
  2003. }
Created with JaCoCo 0.8.8.202204050719