RicezioneBusteService.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.PortaApplicativa;
  38. import org.openspcoop2.core.constants.TipoPdD;
  39. import org.openspcoop2.core.constants.TransferLengthModes;
  40. import org.openspcoop2.core.id.IDPortaApplicativa;
  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.dynamic.DynamicMapBuilderUtils;
  66. import org.openspcoop2.pdd.core.handlers.GestoreHandlers;
  67. import org.openspcoop2.pdd.core.handlers.HandlerException;
  68. import org.openspcoop2.pdd.core.handlers.PostOutResponseContext;
  69. import org.openspcoop2.pdd.core.handlers.PreInAcceptRequestContext;
  70. import org.openspcoop2.pdd.core.handlers.PreInRequestContext;
  71. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  72. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  73. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  74. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  75. import org.openspcoop2.pdd.logger.transazioni.ConfigurazioneTracciamento;
  76. import org.openspcoop2.pdd.logger.transazioni.InformazioniTransazione;
  77. import org.openspcoop2.pdd.logger.transazioni.TracciamentoManager;
  78. import org.openspcoop2.pdd.services.DirectVMProtocolInfo;
  79. import org.openspcoop2.pdd.services.DumpRaw;
  80. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  81. import org.openspcoop2.pdd.services.ServicesUtils;
  82. import org.openspcoop2.pdd.services.connector.ConnectorDispatcherErrorInfo;
  83. import org.openspcoop2.pdd.services.connector.ConnectorDispatcherInfo;
  84. import org.openspcoop2.pdd.services.connector.ConnectorDispatcherUtils;
  85. import org.openspcoop2.pdd.services.connector.ConnectorException;
  86. import org.openspcoop2.pdd.services.connector.RicezioneBusteConnector;
  87. import org.openspcoop2.pdd.services.connector.messages.ConnectorInMessage;
  88. import org.openspcoop2.pdd.services.connector.messages.ConnectorOutMessage;
  89. import org.openspcoop2.pdd.services.connector.messages.DirectVMConnectorInMessage;
  90. import org.openspcoop2.pdd.services.connector.messages.DirectVMConnectorOutMessage;
  91. import org.openspcoop2.pdd.services.connector.messages.DumpRawConnectorInMessage;
  92. import org.openspcoop2.pdd.services.connector.messages.DumpRawConnectorOutMessage;
  93. import org.openspcoop2.pdd.services.core.RicezioneBuste;
  94. import org.openspcoop2.pdd.services.core.RicezioneBusteContext;
  95. import org.openspcoop2.pdd.services.error.RicezioneBusteExternalErrorGenerator;
  96. import org.openspcoop2.protocol.basic.builder.EsitoBuilder;
  97. import org.openspcoop2.protocol.basic.registry.ServiceIdentificationReader;
  98. import org.openspcoop2.protocol.engine.SecurityTokenUtilities;
  99. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  100. import org.openspcoop2.protocol.sdk.builder.EsitoTransazione;
  101. import org.openspcoop2.protocol.sdk.builder.InformazioniErroriInfrastrutturali;
  102. import org.openspcoop2.protocol.sdk.builder.ProprietaErroreApplicativo;
  103. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  104. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  105. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  106. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  107. import org.openspcoop2.protocol.sdk.constants.IDService;
  108. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  109. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  110. import org.openspcoop2.protocol.sdk.state.URLProtocolContext;
  111. import org.openspcoop2.protocol.utils.EsitiProperties;
  112. import org.openspcoop2.utils.LimitExceededIOException;
  113. import org.openspcoop2.utils.LimitedInputStream;
  114. import org.openspcoop2.utils.LoggerWrapperFactory;
  115. import org.openspcoop2.utils.TimeoutIOException;
  116. import org.openspcoop2.utils.TimeoutInputStream;
  117. import org.openspcoop2.utils.Utilities;
  118. import org.openspcoop2.utils.date.DateManager;
  119. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  120. import org.openspcoop2.utils.io.notifier.NotifierInputStreamParams;
  121. import org.openspcoop2.utils.transport.TransportRequestContext;
  122. import org.openspcoop2.utils.transport.http.HttpConstants;
  123. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  124. import org.slf4j.Logger;


  127. /**
  128.  * Contiene la definizione di una servlet 'RicezioneBusteDirect'
  129.  * Si occupa di creare il Messaggio, applicare la logica degli handlers 
  130.  * e passare il messaggio ad OpenSPCoop per lo sbustamento e consegna.
  131.  *
  132.  * @author Poli Andrea (apoli@link.it)
  133.  * @author Lorenzo Nardi (nardi@link.it)
  134.  * @author $Author$
  135.  * @version $Rev$, $Date$
  136.  */

  138. public class RicezioneBusteService  {

  140.     private RicezioneBusteExternalErrorGenerator generatoreErrore;
  141.     
  142.     public RicezioneBusteService(RicezioneBusteExternalErrorGenerator generatoreErrore){
  143.         this.generatoreErrore = generatoreErrore;
  144.     }
  145.     

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

  303.         try{
  304.             GestoreRichieste.readRequestConfig(requestInfo);
  305.         }catch(Exception e){
  306.             String msg = "GestoreRichieste readRequestConfig fallita: "+Utilities.readFirstErrorValidMessageFromException(e);
  307.             logCore.error(msg,e);
  308.             ConnectorDispatcherErrorInfo cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore,
  309.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  310.                         get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_500_ERRORE_INTERNO),
  311.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, e, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  312.             RicezioneBusteServiceUtils.emitTransaction(logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfo);
  313.             return;
  314.         }
  315.             
  316.         if(idTransazione!=null) {
  317.             try {
  318.                 if(openSPCoopProperties.isTransazioniEnabled()) {
  319.                     TransactionContext.createTransaction(idTransazione, "RicezioneBuste.1");
  320.                 }
  321.                 requestInfo.setIdTransazione(idTransazione);
  322.                 this.generatoreErrore.getImbustamentoErrore().setIdTransazione(idTransazione);
  323.                 
  324.                 req.setThresholdContext((context!=null ? context.getPddContext(): null), 
  325.                         openSPCoopProperties.getDumpBinarioInMemoryThreshold(), openSPCoopProperties.getDumpBinarioRepository());
  326.             }catch(Throwable e) {
  327.                 context = null;
  328.                 protocolFactory = null;
  329.                 // non loggo l'errore tanto poi provo a ricreare il context subito dopo e li verra' registrato l'errore
  330.             }
  331.         }
  332.                 
  333.         // Logger dei messaggi diagnostici
  334.         String nomePorta = requestInfo.getProtocolContext().getInterfaceName();
  335.         MsgDiagnostico msgDiag = MsgDiagnostico.newInstance(TipoPdD.APPLICATIVA,idModulo,nomePorta,requestInfo);
  336.         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_BUSTE);
  337.         if(context!=null && protocolFactory!=null) {
  338.             msgDiag.setPddContext(context.getPddContext(), protocolFactory);
  339.         }
  340.         
  341.         try{
  342.             msgDiag.logPersonalizzato("ricezioneRichiesta.firstLog");
  343.         }catch(Exception e){
  344.             logCore.error("Errore generazione diagnostico di ingresso",e);
  345.         }
  346.         
  347.         try{
  348.             req.setDiagnosticProducer(context!=null ? context.getPddContext(): null, msgDiag);
  349.         }catch(Throwable e){
  350.             logCore.error("Errore registrazione diagnostico sulla richiesta",e);
  351.         }
  352.         
  353.         // emitDiagnostic preAccept handler
  354.         GestoreHandlers.emitDiagnostic(msgDiag, preInAcceptRequestContext, context!=null ? context.getPddContext() : null, 
  355.                 logCore, logCore);
  356.         
  357.         // Aggiorno RequestInfo
  358.         try{
  359.             msgDiag.mediumDebug("Accesso configurazione della richiesta in corso...");
  360.         }catch(Exception e){
  361.             logCore.error("Errore generazione diagnostico",e);
  362.         }
  363.         ConnectorDispatcherInfo cInfo = RicezioneBusteServiceUtils.updatePortaApplicativaRequestInfo(requestInfo, logCore, req, res,
  364.                 this.generatoreErrore, serviceIdentificationReader,msgDiag, 
  365.                 context!=null ? context.getPddContext(): null);
  366.         if(cInfo!=null){
  367.             RicezioneBusteServiceUtils.emitTransaction(context, logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfo);
  368.             return; // l'errore in response viene impostato direttamente dentro il metodo
  369.         }
  370.         req.updateRequestInfo(requestInfo);
  371.         
  372.         
  373.         // Timeout e DumpRaw
  374.         DumpRaw dumpRaw = null;
  375.         try{
  376.             try{
  377.                 msgDiag.mediumDebug("Lettura configurazione dump binario ...");
  378.             }catch(Exception e){
  379.                 logCore.error("Errore generazione diagnostico",e);
  380.             }
  381.             boolean dumpBinario = configPdDManager.dumpBinarioPA();
  382.             PortaApplicativa pa = null;
  383.             if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  384.                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  385.                 idPA.setNome(requestInfo.getProtocolContext().getInterfaceName());
  386.                 pa = configPdDManager.getPortaApplicativaSafeMethod(idPA, requestInfo);
  387.             }
  388.             
  389.             // Limited
  390.             try{
  391.                 msgDiag.mediumDebug("Lettura configurazione dimensione massima della richiesta ...");
  392.             }catch(Exception e){
  393.                 logCore.error("Errore generazione diagnostico",e);
  394.             }
  395.             String azione = (requestInfo!=null && requestInfo.getIdServizio()!=null) ? requestInfo.getIdServizio().getAzione() : null;
  396.             SoglieDimensioneMessaggi limitedInputStream = configPdDManager.getSoglieLimitedInputStream(pa, azione, idModulo,
  397.                     (context!=null && context.getPddContext()!=null) ? context.getPddContext() : null, 
  398.                     requestInfo,
  399.                     protocolFactory, logCore);
  400.             if(limitedInputStream!=null) {
  401.                 req.setRequestLimitedStream(limitedInputStream.getRichiesta());
  402.                 if(context!=null && context.getPddContext()!=null) {
  403.                     context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.LIMITED_STREAM, limitedInputStream.getRisposta());
  404.                 }
  405.             }
  406.             else {
  407.                 if(!openSPCoopProperties.isLimitedInputStreamThresholdDefined()) {
  408.                     req.disableLimitedStream();
  409.                 }
  410.             }
  411.             
  412.             // Timeout
  413.             try{
  414.                 msgDiag.mediumDebug("Lettura configurazione timeout per la lettura della richiesta ...");
  415.             }catch(Exception e){
  416.                 logCore.error("Errore generazione diagnostico",e);
  417.             }
  418.             boolean useTimeoutInputStream = configPdDManager.isConnettoriUseTimeoutInputStream(pa);
  419.             if(useTimeoutInputStream) {
  420.                 SogliaReadTimeout timeout = configPdDManager.getRequestReadTimeout(pa,
  421.                         requestInfo,
  422.                         protocolFactory, 
  423.                         context!=null ? context.getPddContext() : null,
  424.                         null);
  425.                 if(timeout!=null && timeout.getSogliaMs()>0) {
  426.                     req.setRequestReadTimeout(timeout);
  427.                 }
  428.                 else {
  429.                     req.disableReadTimeout();
  430.                 }
  431.             }
  432.             else {
  433.                 req.disableReadTimeout();
  434.             }
  435.             
  436.             // DumpRaw
  437.             try{
  438.                 msgDiag.mediumDebug("Lettura configurazione dump ...");
  439.             }catch(Exception e){
  440.                 logCore.error("Errore generazione diagnostico",e);
  441.             }
  442.             DumpConfigurazione dumpConfigurazione = configPdDManager.getDumpConfigurazione(pa);
  443.             ConfigurazioneTracciamento configurazioneTracciamento = new ConfigurazioneTracciamento(logCore, configPdDManager, pa);
  444.             boolean fileTraceHeaders = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioHeaderEnabled();
  445.             boolean fileTracePayload = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioPayloadEnabled();
  446.             dumpRaw = new DumpRaw(logCore, requestInfo.getIdentitaPdD(), idModulo, TipoPdD.APPLICATIVA, 
  447.                     dumpBinario, 
  448.                     dumpConfigurazione,
  449.                     fileTraceHeaders, fileTracePayload);
  450.             if(dumpRaw.isActiveDumpRichiesta()) {
  451.                 req = new DumpRawConnectorInMessage(logCore, req, 
  452.                         (context!=null ? context.getPddContext(): null), 
  453.                         openSPCoopProperties.getDumpBinarioInMemoryThreshold(), openSPCoopProperties.getDumpBinarioRepository());
  454.             }
  455.             if(dumpRaw.isActiveDumpRisposta()) {
  456.                 res = new DumpRawConnectorOutMessage(logCore, res, 
  457.                         (context!=null ? context.getPddContext(): null), 
  458.                         openSPCoopProperties.getDumpBinarioInMemoryThreshold(), openSPCoopProperties.getDumpBinarioRepository(),
  459.                         dumpRaw);
  460.             }
  461.         }catch(Throwable e){
  462.             String msg = "Inizializzazione di GovWay non correttamente effettuata: DumpRaw";
  463.             logCore.error(msg,  e);
  464.             cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore, 
  465.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  466.                         get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA), 
  467.                         IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, e, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  468.             RicezioneBusteServiceUtils.emitTransaction(logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfo);
  469.             return;
  470.         }
  471.         
  472.         
  473.         // API Soap supporta solo POST e ?wsdl
  474.         if(ServiceBinding.SOAP.equals(requestInfo.getProtocolServiceBinding())){
  475.             HttpRequestMethod method = null;
  476.             if(req!=null && req.getURLProtocolContext()!=null && req.getURLProtocolContext().getRequestType()!=null) {
  477.                 try {
  478.                     method = HttpRequestMethod.valueOf(req.getURLProtocolContext().getRequestType());
  479.                 }catch(Exception e) {
  480.                     // ignore
  481.                 }
  482.             }
  483.             if(method!=null && !HttpRequestMethod.POST.equals(method)){
  484.                 if(ServicesUtils.isRequestWsdl(req, logCore)) {
  485.                     try {
  486.                         ServicesUtils.writeWsdl(res, requestInfo, RicezioneBusteConnector.ID_SERVICE, serviceIdentificationReader, logCore);
  487.                     }catch(Exception e) {
  488.                         String msg = "Lettura wsdl fallita: "+Utilities.readFirstErrorValidMessageFromException(e);
  489.                         logCore.error(msg,e);
  490.                         cInfo = ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore,
  491.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  492.                                 get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_500_ERRORE_INTERNO),
  493.                                 IntegrationFunctionError.INTERNAL_REQUEST_ERROR, e, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  494.                         // nel caso di wsdl request non emetto la transazione
  495.                         //RicezioneBusteServiceUtils.emitTransaction(context,logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfo);
  496.                     }finally {
  497.                         // FIX devo però rilasciare dalla memoria la transazione:
  498.                         if(openSPCoopProperties.isTransazioniEnabled()) {
  499.                             idTransazione = (String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  500.                             TransactionContext.removeTransaction(idTransazione);
  501.                         }
  502.                     }
  503.                     return;
  504.                 }
  505.                 else {
  506.                     String msg = "Metodo http '"+method+"' non supportato dall'API SOAP invocata";
  507.                     logCore.error(msg);
  508.                     ConnectorDispatcherErrorInfo cInfoError =  ConnectorDispatcherUtils.doError(requestInfo, this.generatoreErrore,
  509.                             ErroriIntegrazione.ERRORE_439_FUNZIONALITA_NOT_SUPPORTED_BY_PROTOCOL.getErrore439_FunzionalitaNotSupportedByProtocol(msg, protocolFactory),
  510.                             IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL, null, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  511.                     RicezioneBusteServiceUtils.emitTransaction(context, logCore, req, pddContextFromServlet, dataAccettazioneRichiesta, cInfoError);
  512.                     return;
  513.                 }
  514.             }
  515.         }       
  516.         
  517.         
  518.         
  519.         

  521.         
  522.         
  523.         
  524.         
  525.         
  526.         
  527.         
  528.         /* ------------  Lettura parametri della richiesta ------------- */
  529.         
  530.         
  531.         //  Risposta Soap
  532.         OpenSPCoop2Message responseMessage = null;

  534.         // Proprieta errore applicativo
  535.         ProprietaErroreApplicativo proprietaErroreAppl = null;

  537.         // PostOutResponseContext
  538.         PostOutResponseContext postOutResponseContext = null;

  540.         PdDContext pddContext = null;
  541.         OpenSPCoop2Message requestMessage = null;
  542.         
  543.         
  544.         String protocol = null;
  545.         MessageType messageTypeReq = null;
  546.         ServiceBinding protocolServiceBinding = null;
  547.         try{
  548.             
  549.             /* --------------- Creo il context che genera l'id univoco ----------------------- */
  550.             
  551.             try{
  552.                 msgDiag.mediumDebug("Creazione contesto ...");
  553.             }catch(Exception e){
  554.                 logCore.error("Errore generazione diagnostico",e);
  555.             }
  556.             if(protocolFactory==null) {
  557.                 protocolFactory = req.getProtocolFactory();
  558.             }
  559.             protocol = protocolFactory.getProtocol();
  560.             
  561.             protocolServiceBinding = requestInfo.getProtocolServiceBinding();
  562.             
  563.             proprietaErroreAppl = openSPCoopProperties.getProprietaGestioneErrorePD(protocolFactory.createProtocolManager());
  564.             proprietaErroreAppl.setDominio(openSPCoopProperties.getIdentificativoPortaDefault(protocolFactory.getProtocol(), requestInfo));
  565.             proprietaErroreAppl.setIdModulo(idModulo);
  566.             
  567.             if(context==null) {
  568.                 context = new RicezioneBusteContext(idModuloAsService, dataAccettazioneRichiesta,requestInfo);
  569.             }
  570.             if(preInAcceptRequestContext!=null && preInAcceptRequestContext.getPreContext()!=null && !preInAcceptRequestContext.getPreContext().isEmpty()) {
  571.                 context.getPddContext().addAll(preInAcceptRequestContext.getPreContext(), false);
  572.             }
  573.             context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME, protocolFactory.getProtocol());
  574.             context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO, req.getRequestInfo());
  575.             RicezionePropertiesConfig rConfig = RicezioneBusteServiceUtils.readPropertiesConfig(req.getRequestInfo(), logCore,null);
  576.             if(rConfig!=null) {
  577.                 if (rConfig.getApiImplementation() != null && !rConfig.getApiImplementation().isEmpty()) {
  578.                    context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_CONFIGURAZIONE, rConfig.getApiImplementation());
  579.                 }
  580.                 if (rConfig.getSoggettoErogatore() != null && !rConfig.getSoggettoErogatore().isEmpty()) {
  581.                     context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_EROGATORE, rConfig.getSoggettoErogatore());
  582.                 }
  583.             }
  584.             context.setTipoPorta(TipoPdD.APPLICATIVA);
  585.             context.setIdModulo(idModulo);
  586.             msgDiag.setPddContext(context.getPddContext(), protocolFactory);
  587.             pddContext = context.getPddContext();
  588.             DynamicMapBuilderUtils.injectDynamicMap(null, requestInfo, pddContext, logCore); // per le funzioni di generazione risposta errore
  589.                         
  590.             try{
  591.                 if(openSPCoopProperties.isTransazioniEnabled()) {
  592.                     // NOTA: se gia' esiste con l'id di transazione, non viene ricreata
  593.                     TransactionContext.createTransaction((String)pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE), "RicezioneBuste.2");
  594.                 }
  595.             }catch(Exception e){
  596.                 logCore.error("Errore durante la creazione della transazione",e);
  597.             }
  598.             
  599.             try{
  600.                 msgDiag.logPersonalizzato("ricezioneRichiesta.firstAccessRequestStream");
  601.             }catch(Exception e){
  602.                 logCore.error("Errore generazione diagnostico di ingresso (stream access)",e);
  603.             }
  604.             
  605.             if(dumpRaw!=null && dumpRaw.isActiveDump()){
  606.                 dumpRaw.setPddContext(msgDiag.getPorta(), context.getPddContext());
  607.                 dumpRaw.serializeContext(context, protocol);
  608.             }
  609.             
  610.             DirectVMConnectorInMessage vm = null;
  611.             if(req instanceof DirectVMConnectorInMessage){
  612.                 vm = (DirectVMConnectorInMessage) req;
  613.             }
  614.             else if(req instanceof DumpRawConnectorInMessage){
  615.                 if( ((DumpRawConnectorInMessage)req).getWrappedConnectorInMessage() instanceof DirectVMConnectorInMessage ){
  616.                     vm = (DirectVMConnectorInMessage) ((DumpRawConnectorInMessage)req).getWrappedConnectorInMessage();
  617.                 }
  618.             }
  619.             if(vm!=null && vm.getDirectVMProtocolInfo()!=null){
  620.                 vm.getDirectVMProtocolInfo().setInfo(pddContext);
  621.             }
  622.             
  623.             
  624.             
  625.             
  626.             
  627.             /* ------------  PostOutResponseContext ------------- */
  628.             postOutResponseContext = new PostOutResponseContext(logCore, protocolFactory);
  629.             postOutResponseContext.setTipoPorta(TipoPdD.APPLICATIVA);
  630.             postOutResponseContext.setPddContext(pddContext);
  631.             postOutResponseContext.setIdModulo(idModulo);
  632.             
  633.             
  634.             
  635.                     
  636.             /* ------------  PreInHandler ------------- */
  637.             
  638.             // build context
  639.             PreInRequestContext preInRequestContext = new PreInRequestContext(pddContext);
  640.             if(pddContextFromServlet!=null){
  641.                 preInRequestContext.getPddContext().addAll(pddContextFromServlet, true);
  642.             }
  643.             preInRequestContext.setTipoPorta(TipoPdD.APPLICATIVA);
  644.             preInRequestContext.setIdModulo(idModulo);
  645.             preInRequestContext.setProtocolFactory(protocolFactory);
  646.             preInRequestContext.setRequestInfo(requestInfo);
  647.             Map<String, Object> transportContext = new HashMap<>();
  648.             transportContext.put(PreInRequestContext.SERVLET_REQUEST, req);
  649.             transportContext.put(PreInRequestContext.SERVLET_RESPONSE, res);
  650.             preInRequestContext.setTransportContext(transportContext);  
  651.             preInRequestContext.setLogCore(logCore);
  652.                         
  653.             // invocazione handler
  654.             GestoreHandlers.preInRequest(preInRequestContext, msgDiag, logCore);
  655.             
  656.             // aggiungo eventuali info inserite nel preInHandler
  657.             pddContext.addAll(preInRequestContext.getPddContext(), false);
  658.             
  659.             // Lettura risposta parametri NotifierInputStream
  660.             NotifierInputStreamParams notifierInputStreamParams = preInRequestContext.getNotifierInputStreamParams();
  661.             context.setNotifierInputStreamParams(notifierInputStreamParams);
  662.             
  663.             // Controllo Content Length se attiva una policy di rate limiting
  664.             req.checkContentLengthLimit();
  665.             
  666.             // Lettura richiesta con il dump
  667.             if(dumpRaw!=null && dumpRaw.isActiveDumpRichiesta()){
  668.                 dumpRaw.serializeRequest(((DumpRawConnectorInMessage)req), true, notifierInputStreamParams);
  669.                 dataIngressoRichiesta = req.getDataIngressoRichiesta();
  670.                 context.setDataIngressoRichiesta(dataIngressoRichiesta);
  671.             }
  672.             
  673.             

  675.             
  676.             
  677.             
  678.             
  679.             
  680.             /* ------------ Controllo ContentType -------------------- */
  681.             
  682.             msgDiag.logPersonalizzato("ricezioneRichiesta.elaborazioneDati.tipologiaMessaggio");
  683.             
  684.             messageTypeReq = requestInfo.getProtocolRequestMessageType();
  685.             if(ServiceBinding.SOAP.equals(protocolServiceBinding) && messageTypeReq!=null){
  686.                 msgDiag.addKeyword(CostantiPdD.KEY_SOAP_VERSION, messageTypeReq.getMessageVersionAsString());
  687.                 msgDiag.addKeyword(CostantiPdD.KEY_SOAP_ENVELOPE_NAMESPACE_ATTESO, SoapUtils.getSoapEnvelopeNS(messageTypeReq));
  688.             }
  689.             
  690.             String contentTypeReq = req.getContentType();
  691.             boolean contentTypeSupportato = messageTypeReq!=null;
  692.             msgDiag.addKeyword(CostantiPdD.KEY_CONTENT_TYPES_ATTESI, 
  693.                     requestInfo.getBindingConfig().getContentTypesSupportedAsString(protocolServiceBinding, 
  694.                             MessageRole.REQUEST,requestInfo.getProtocolContext()));
  695.             List<String> supportedContentTypes = requestInfo.getBindingConfig().getContentTypesSupported(protocolServiceBinding, 
  696.                     MessageRole.REQUEST,requestInfo.getProtocolContext()); 
  697.             msgDiag.addKeyword(CostantiPdD.KEY_HTTP_HEADER, contentTypeReq);
  698.             
  699.             if(ServiceBinding.SOAP.equals(protocolServiceBinding)){ 
  700.                 if(openSPCoopProperties.isControlloContentTypeAbilitatoRicezioneBuste() == false){
  701.                     if(!contentTypeSupportato){
  702.                         if(HttpConstants.CONTENT_TYPE_NON_PRESENTE.equals(contentTypeReq)){
  703.                             msgDiag.logPersonalizzato("contentType.notDefined");
  704.                         }else{
  705.                             msgDiag.logPersonalizzato("contentType.unsupported");
  706.                         }
  707.                         messageTypeReq = MessageType.SOAP_11;
  708.                         contentTypeReq = SoapUtils.getSoapContentTypeForMessageWithoutAttachments(messageTypeReq); // Forzo text/xml;
  709.                         logCore.warn("Content-Type non supportato, viene utilizzato forzatamente il tipo: "+contentTypeReq);
  710.                         contentTypeSupportato = true;
  711.                     }
  712.                 }
  713.             }
  714.             if(!contentTypeSupportato){
  715.                 
  716.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  717.                 
  718.                 // Leggo content Type dall'header HTTP per capire se l'header proprio non esiste o se e' il valore errato.
  719.                 if(HttpConstants.CONTENT_TYPE_NON_PRESENTE.equals(contentTypeReq)){
  720.                     //ContentType del messaggio non presente
  721.                     msgDiag.logPersonalizzato("contentType.notDefined");
  722.                     responseMessage = this.generatoreErrore.buildErroreProcessamento(pddContext, IntegrationFunctionError.CONTENT_TYPE_NOT_PROVIDED,
  723.                             ErroriIntegrazione.ERRORE_433_CONTENT_TYPE_NON_PRESENTE.getErrore433_ContentTypeNonPresente(supportedContentTypes));    
  724.                 }   
  725.                 else{
  726.                     //ContentType del messaggio non supportato
  727.                     msgDiag.logPersonalizzato("contentType.unsupported");
  728.                     responseMessage = this.generatoreErrore.buildErroreProcessamento(pddContext, IntegrationFunctionError.CONTENT_TYPE_NOT_SUPPORTED,
  729.                             ErroriIntegrazione.ERRORE_429_CONTENT_TYPE_NON_SUPPORTATO.getErrore429_ContentTypeNonSupportato(contentTypeReq,supportedContentTypes)); 
  730.                 }
  731.             }
  732.             else{
  733.                 /* ------------ Check Charset ------------- */
  734.                 try {
  735.                     boolean checkEnabled = false;
  736.                     List<String> ctDefault = null;
  737.                     if(ServiceBinding.SOAP.equals(protocolServiceBinding)){
  738.                         if(openSPCoopProperties.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap()) {
  739.                             checkEnabled = true;
  740.                             ctDefault = openSPCoopProperties.getControlloCharsetContentTypeAbilitatoRicezioneBusteSoap();
  741.                         }
  742.                     }
  743.                     else {
  744.                         if(openSPCoopProperties.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest()) {
  745.                             checkEnabled = true;
  746.                             ctDefault = openSPCoopProperties.getControlloCharsetContentTypeAbilitatoRicezioneBusteRest();
  747.                         }
  748.                     }
  749.                     if(checkEnabled) {
  750.                         ServicesUtils.checkCharset(contentTypeReq, ctDefault, msgDiag, true, TipoPdD.APPLICATIVA);
  751.                     }
  752.                     
  753.                 }catch(Throwable t) {
  754.                     logCore.error("Avvenuto errore durante il controllo del charset della richiesta: "+t.getMessage(),t);
  755.                 }
  756.                                 
  757.                 /* ------------  SoapAction check 1 (controlla che non sia null e ne ritorna il valore) ------------- */            
  758.                 String soapAction = null;
  759.                 try{
  760.                     if(ServiceBinding.SOAP.equals(protocolServiceBinding)){
  761.                         soapAction = req.getSOAPAction();
  762.                     }
  763.                 }catch(Exception e){
  764.                     if(dataIngressoRichiesta==null) {
  765.                         dataIngressoRichiesta=DateManager.getDate();
  766.                     }
  767.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  768.                     throw e;
  769.                 }
  770.                 
  771.                 /* ------------ Costruzione Messaggio -------------------- */
  772.                 msgDiag.logPersonalizzato("ricezioneRichiesta.elaborazioneDati.inCorso");
  773.                 Utilities.printFreeMemory("RicezioneBuste - Pre costruzione richiesta");
  774.                 OpenSPCoop2MessageParseResult pr = req.getRequest(notifierInputStreamParams);
  775.                 if(pr.getParseException()!=null){
  776.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, pr.getParseException());
  777.                 }
  778.                 dataIngressoRichiesta = req.getDataIngressoRichiesta();
  779.                 context.setDataIngressoRichiesta(dataIngressoRichiesta);
  780.                 requestMessage = pr.getMessage_throwParseException();
  781.                 Utilities.printFreeMemory("RicezioneBuste - Post costruzione richiesta");
  782.                 requestMessage.setProtocolName(protocolFactory.getProtocol());
  783.                 requestMessage.setTransactionId(PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext));
  784.                 requestMessage.addContextProperty(org.openspcoop2.core.constants.Costanti.REQUEST_INFO,requestInfo); // serve nelle comunicazione non stateless (es. riscontro salvato) per poterlo rispedire
  785.                 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
  786.                 Object nomePortaInvocataObject = context.getPddContext().getObject(CostantiPdD.NOME_PORTA_INVOCATA);
  787.                 if(nomePortaInvocataObject!=null && nomePortaInvocataObject instanceof String) {
  788.                     requestMessage.addContextProperty(CostantiPdD.NOME_PORTA_INVOCATA, (String) nomePortaInvocataObject );
  789.                 }               
  790.                             
  791.                 /* ------------ Controllo Soap namespace -------------------- */
  792.                 String soapEnvelopeNamespaceVersionMismatch = null;
  793.                 try{
  794.                     if(ServiceBinding.SOAP.equals(protocolServiceBinding)){
  795.                         soapEnvelopeNamespaceVersionMismatch = ServicesUtils.checkSOAPEnvelopeNamespace(requestMessage.castAsSoap(), messageTypeReq);
  796.                     }
  797.                 }catch(Exception e){
  798.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  799.                     throw e;
  800.                 }
  801.     
  802.                 /* ------------ Controllo MustUnderstand -------------------- */
  803.                 String mustUnderstandError = null;
  804.                 if(soapEnvelopeNamespaceVersionMismatch==null) {
  805.                     try{
  806.                         if(ServiceBinding.SOAP.equals(protocolServiceBinding)){
  807.                             mustUnderstandError = ServicesUtils.checkMustUnderstand(requestMessage.castAsSoap(),protocolFactory);
  808.                         }
  809.                     }catch(Exception e){
  810.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  811.                         throw e;
  812.                     }
  813.                 }
  814.                 
  815.                 /* ------------  SoapAction check 2 ------------- */
  816.                 if(soapAction!=null){
  817.                     if(openSPCoopProperties.checkSoapActionQuotedString_ricezioneBuste()){
  818.                         try{
  819.                             SoapUtils.checkSoapActionQuotedString(soapAction, messageTypeReq);
  820.                         }catch(Exception e){
  821.                             pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  822.                             throw e;
  823.                         }
  824.                     }
  825.                 }

  827.                 /* --------------- SecurityToken --------------- */
  828.                 try {
  829.                     if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getCredential()!=null && 
  830.                             requestInfo.getProtocolContext().getCredential().getCertificate()!=null &&
  831.                             requestInfo.getProtocolContext().getCredential().getCertificate().getCertificate()!=null) {
  832.                         SecurityTokenUtilities.newSecurityToken(pddContext);
  833.                     }
  834.                 }catch(Exception e){
  835.                     logCore.error("Costruzione SecurityToken non riuscito: "+e.getMessage(),e);
  836.                 }
  837.                                 
  838.                 /* ------------  Elaborazione ------------- */
  839.                 
  840.                 if(mustUnderstandError==null && soapEnvelopeNamespaceVersionMismatch==null){
  841.                     
  842.                     // Contesto di Richiesta
  843.                     context.setCredenziali(new Credenziali(req.getCredential()));
  844.                     context.setGestioneRisposta(true); // siamo in una servlet, la risposta deve essere aspettata
  845.                     context.setMessageRequest(requestMessage);
  846.                     context.setTracciamentoAbilitato(true);
  847.                     context.setUrlProtocolContext(requestInfo.getProtocolContext());
  848.                     context.setMsgDiagnostico(msgDiag);
  849.     
  850.                     // Log elaborazione dati completata
  851.                     msgDiag.logPersonalizzato("ricezioneRichiesta.elaborazioneDati.completata");
  852.             
  853.                     // se il tracciamento lo prevedo emetto un log
  854.                     registraTracciaInRequest(context, protocolFactory, logCore, msgDiag);
  855.                     
  856.                     // Invocazione...
  857.                     RicezioneBuste gestoreRichiesta = new RicezioneBuste(context, this.generatoreErrore);
  858.                     gestoreRichiesta.process(req);
  859.                     responseMessage = context.getMessageResponse();
  860.                 }   
  861.                 else{
  862.                     if(mustUnderstandError!=null){
  863.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  864.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, mustUnderstandError);
  865.                         msgDiag.logPersonalizzato("mustUnderstand.unknown");
  866.                         responseMessage = this.generatoreErrore.buildErroreProcessamento(pddContext, IntegrationFunctionError.SOAP_MUST_UNDERSTAND_UNKNOWN,
  867.                                 ErroriIntegrazione.ERRORE_427_MUSTUNDERSTAND_ERROR.getErrore427_MustUnderstandHeaders(mustUnderstandError));
  868.                     }
  869.                     else{
  870.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  871.                         msgDiag.addKeyword(CostantiPdD.KEY_SOAP_ENVELOPE_NAMESPACE, soapEnvelopeNamespaceVersionMismatch);
  872.                         msgDiag.logPersonalizzato("soapEnvelopeNamespace.versionMismatch");
  873.                         responseMessage = this.generatoreErrore.buildErroreProcessamento(pddContext, IntegrationFunctionError.SOAP_VERSION_MISMATCH,
  874.                                 ErroriIntegrazione.ERRORE_430_SOAP_ENVELOPE_NAMESPACE_ERROR.
  875.                                     getErrore430_SoapNamespaceNonSupportato(messageTypeReq, soapEnvelopeNamespaceVersionMismatch));
  876.                     }
  877.                 }
  878.             }
  879.                 
  880.         } catch (Throwable e) {
  881.             
  882.             if(context==null){
  883.                 // Errore durante la generazione dell'id
  884.                 context = RicezioneBusteContext.newRicezioneBusteContext(idModuloAsService,dataAccettazioneRichiesta,requestInfo);
  885.                 context.setDataIngressoRichiesta(dataIngressoRichiesta);
  886.                 context.setTipoPorta(TipoPdD.APPLICATIVA);
  887.                 context.setIdModulo(idModulo);
  888.                 context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME, protocolFactory.getProtocol());
  889.                 pddContext = context.getPddContext();
  890.                 msgDiag.setPddContext(pddContext,protocolFactory);
  891.                 if(postOutResponseContext!=null){
  892.                     postOutResponseContext.setPddContext(pddContext);
  893.                 }
  894.             }

  896.             // Se viene lanciata una eccezione, riguarda la richiesta, altrimenti è gestita dopo nel finally.
  897.             Throwable tParsing = null;
  898.             ParseException parseException = null;
  899.             if(pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION)){
  900.                 parseException = (ParseException) pddContext.removeObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  901.                 if(parseException!=null) {
  902.                     tParsing = parseException.getParseException();
  903.                 }
  904.             }
  905.             if(tParsing==null && (requestMessage==null || requestMessage.getParseException() == null)){
  906.                 tParsing = ParseExceptionUtils.getParseException(e);
  907.             }
  908.             
  909.             // Genero risposta con errore
  910.             String msgErrore = e.getMessage();
  911.             if(msgErrore==null){
  912.                 msgErrore = e.toString();
  913.             }
  914.                 
  915.             // Ricerca org.xml.sax.SAXParseException || com.ctc.wstx.exc.WstxParsingException ||  com.ctc.wstx.exc.WstxUnexpectedCharException
  916.             if( ServiceBinding.SOAP.equals(protocolServiceBinding) &&
  917.                     messageTypeReq!=null &&
  918.                     (
  919.                     
  920.                         // Messaggio lanciato dallo streaming engine
  921.                         msgErrore.equals("Transport level information does not match with SOAP Message namespace URI") ||
  922.                         // ?
  923.                         msgErrore.equals("I dati ricevuti non rappresentano un messaggio SOAP 1.1 valido: ") ||
  924.                         // 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
  925.                         // Proprio nel caso il namespace non corrisponde al tipo atteso.
  926.                         msgErrore.equals("InputStream does not represent a valid SOAP 1.1 Message") || 
  927.                         msgErrore.equals("InputStream does not represent a valid SOAP 1.2 Message")
  928.                     )
  929.                 ){
  930.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  931.                 msgDiag.addKeyword(CostantiPdD.KEY_SOAP_ENVELOPE_NAMESPACE, "Impossibile recuperare il valore del namespace");
  932.                 msgDiag.logPersonalizzato("soapEnvelopeNamespace.versionMismatch");
  933.                 responseMessage = this.generatoreErrore.buildErroreProcessamento(pddContext, IntegrationFunctionError.SOAP_VERSION_MISMATCH,
  934.                         ErroriIntegrazione.ERRORE_430_SOAP_ENVELOPE_NAMESPACE_ERROR.
  935.                             getErrore430_SoapNamespaceNonSupportato(messageTypeReq,  "Impossibile recuperare il valore del namespace"));
  936.             }
  937.             else if(tParsing!=null){
  938.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  939.                 msgErrore = tParsing.getMessage();
  940.                 if(msgErrore==null){
  941.                     msgErrore = tParsing.toString();
  942.                 }
  943.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  944.                 logCore.error("parsingExceptionRichiesta",e);
  945.                 msgDiag.logPersonalizzato("parsingExceptionRichiesta");
  946.                 
  947.                 IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.UNPROCESSABLE_REQUEST_CONTENT;
  948.                 if( parseException!=null && parseException.getSourceException()!=null &&
  949.                         TimeoutIOException.isTimeoutIOException(parseException.getSourceException())) {
  950.                     integrationFunctionError = IntegrationFunctionError.REQUEST_TIMED_OUT;
  951.                 }
  952.                 else if( parseException!=null && parseException.getSourceException()!=null &&
  953.                         LimitExceededIOException.isLimitExceededIOException(parseException.getSourceException())) {
  954.                     integrationFunctionError = IntegrationFunctionError.REQUEST_SIZE_EXCEEDED;
  955.                 }
  956.                 
  957.                 // Richiesto da certificazione DigitPA
  958.                 responseMessage = this.generatoreErrore.buildErroreIntestazione(pddContext, integrationFunctionError,
  959.                         ErroriIntegrazione.ERRORE_432_PARSING_EXCEPTION_RICHIESTA.getErrore432_MessaggioRichiestaMalformato(tParsing));
  960.             }
  961.             else if (e instanceof HandlerException) {
  962.                 logCore.error("ErroreGenerale (HandlerException)",e);
  963.                 HandlerException he = (HandlerException) e;
  964.                 if(he.isEmettiDiagnostico()) {
  965.                     msgDiag.logErroreGenerico(e, "Generale(richiesta-handler)");
  966.                 }
  967.                 ErroreIntegrazione errore = he.convertToErroreIntegrazione();
  968.                 if(errore==null) {
  969.                     errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento("Generale(richiesta)");
  970.                 }
  971.                 IntegrationFunctionError integrationError = he.getIntegrationFunctionError();
  972.                 if(integrationError==null) {
  973.                     integrationError = IntegrationFunctionError.BAD_REQUEST;
  974.                 }
  975.                 responseMessage = this.generatoreErrore.buildErroreProcessamento(pddContext, integrationError,errore,e);
  976.                 he.customized(responseMessage);
  977.             }
  978.             else{
  979.                 logCore.error("ErroreGenerale",e);
  980.                 msgDiag.logErroreGenerico(e, "Generale(richiesta)");
  981.                 responseMessage = this.generatoreErrore.buildErroreProcessamento(pddContext, IntegrationFunctionError.BAD_REQUEST,
  982.                         ErroriIntegrazione.ERRORE_426_SERVLET_ERROR.getErrore426_ServletError(true, e), e);
  983.             }

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

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


  1176.         
  1177.         // Imposto risposta

  1179.         Date dataPrimaSpedizioneRisposta = DateManager.getDate();
  1180.         Date dataRispostaSpedita = null; 
  1181.         Transazione transazioneDaAggiornare = null;

  1183.         if(context.getMsgDiagnostico()!=null){
  1184.             msgDiag = context.getMsgDiagnostico();
  1185.         }
  1186.         if(context.getResponseHeaders()==null) {
  1187.             context.setResponseHeaders(new HashMap<>());
  1188.         }
  1189.         ServicesUtils.setGovWayHeaderResponse(requestMessage!=null ? requestMessage.getServiceBinding() : requestInfo.getProtocolServiceBinding(),
  1190.                 responseMessage, openSPCoopProperties,
  1191.                 context.getResponseHeaders(), logCore, false, context.getPddContext(), requestInfo);
  1192.         if(context.getResponseHeaders()!=null){
  1193.             Iterator<String> keys = context.getResponseHeaders().keySet().iterator();
  1194.             while (keys.hasNext()) {
  1195.                 String key = (String) keys.next();
  1196.                 List<String> values = context.getResponseHeaders().get(key);
  1197.                 if(values!=null && !values.isEmpty()) {
  1198.                     for (int i = 0; i < values.size(); i++) {
  1199.                         String value = values.get(i);
  1200.                         String verbo = "";
  1201.                         try{
  1202.                             if(i==0) {
  1203.                                 verbo = "set";
  1204.                                 res.setHeader(key,value);
  1205.                             }
  1206.                             else {
  1207.                                 verbo = "add";
  1208.                                 res.addHeader(key,value);
  1209.                             }
  1210.                         }catch(Exception e){
  1211.                             logCore.error("Response."+verbo+"Header("+key+","+value+") error: "+e.getMessage(),e);
  1212.                         }   
  1213.                     }
  1214.                 }
  1215.             }   
  1216.         }
  1217.         if(context!=null && context.getProtocol()!=null){
  1218.             
  1219.             this.generatoreErrore.updateDominio(context.getIdentitaPdD());

  1221.             IDServizio idServizio = null;
  1222.             try{
  1223.                 idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(context.getProtocol().getTipoServizio(), 
  1224.                         context.getProtocol().getServizio(), 
  1225.                         context.getProtocol().getErogatore(), 
  1226.                         context.getProtocol().getVersioneServizio());
  1227.             }catch(Exception e){ 
  1228.                 // non dovrebbe succedere eccezione}
  1229.             }
  1230.             if(idServizio!=null){
  1231.                 idServizio.setAzione(context.getProtocol().getAzione());
  1232.                 this.generatoreErrore.updateInformazioniCooperazione(context.getProtocol().getFruitore(), idServizio);
  1233.             }
  1234.             
  1235.             String servizioApplicativo = null;
  1236.             if(context.getIntegrazione()!=null){
  1237.                 servizioApplicativo = context.getIntegrazione().getServizioApplicativoFruitore();
  1238.             }
  1239.             this.generatoreErrore.updateInformazioniCooperazione(servizioApplicativo);
  1240.             
  1241.         }
  1242.         DirectVMConnectorOutMessage vm = null;
  1243.         if(res instanceof DirectVMConnectorOutMessage){
  1244.             vm = (DirectVMConnectorOutMessage) res;
  1245.         }
  1246.         else if(req instanceof DumpRawConnectorOutMessage){
  1247.             if( ((DumpRawConnectorOutMessage)res).getWrappedConnectorOutMessage() instanceof DirectVMConnectorOutMessage ){
  1248.                 vm = (DirectVMConnectorOutMessage) ((DumpRawConnectorOutMessage)res).getWrappedConnectorOutMessage();
  1249.             }
  1250.         }
  1251.         if(vm!=null){
  1252.             if(context!=null && context.getPddContext()!=null){
  1253.                 DirectVMProtocolInfo pInfo = new DirectVMProtocolInfo();
  1254.                 Object oIdTransazione = context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  1255.                 if(oIdTransazione!=null){
  1256.                     pInfo.setIdTransazione((String)oIdTransazione);
  1257.                 }
  1258.                 if(context.getProtocol()!=null){
  1259.                     if(context.getProtocol().getIdRichiesta()!=null){
  1260.                         pInfo.setIdMessaggioRichiesta(context.getProtocol().getIdRichiesta());
  1261.                     }
  1262.                     if(context.getProtocol().getIdRisposta()!=null){
  1263.                         pInfo.setIdMessaggioRisposta(context.getProtocol().getIdRisposta());
  1264.                     }
  1265.                 }
  1266.                 vm.setDirectVMProtocolInfo(pInfo);
  1267.             }
  1268.         }
  1269.         
  1270.         InformazioniErroriInfrastrutturali informazioniErrori = ServicesUtils.readInformazioniErroriInfrastrutturali(pddContext);
  1271.         
  1272.         OpenSPCoop2Message responseMessageError = null;
  1273.         EsitoTransazione esito = null;
  1274.         String descrizioneSoapFault = "";
  1275.         int statoServletResponse = 200;
  1276.         Throwable erroreConsegnaRisposta = null;    
  1277.         boolean httpEmptyResponse = false;
  1278.         boolean erroreConnessioneClient = false;
  1279.         boolean erroreResponseTimeout = false;
  1280.         boolean erroreResponsePayloadTooLarge = false;
  1281.         boolean sendInvoked = false;
  1282.         boolean registraTracciaOutResponse = false;
  1283.         try{

  1285.             // Invio la risposta
  1286.             if(responseMessage!=null && !responseMessage.isForcedEmptyResponse() && (responseMessage.getForcedResponse()==null)){
  1287.                     
  1288.                 // force response code
  1289.                 if(responseMessage.getForcedResponseCode()!=null){
  1290.                     try{
  1291.                         statoServletResponse = Integer.parseInt(responseMessage.getForcedResponseCode());
  1292.                     }catch(Exception e){
  1293.                         // ignore
  1294.                     }
  1295.                 }
  1296.                 
  1297.                 // Puo' capitare che il messaggio abbia avuto un errore di parsing, 
  1298.                 // ma in alcuni test della testsuite capita che non venga sollevata
  1299.                 // nuovamente nei successivi accessi e venga serializzato un messaggio malformato. 
  1300.                 // Faccio un check esplicito. In altre servlet non e' stato necessario.
  1301.                                 
  1302.                 if(responseMessage.getParseException() != null)
  1303.                     throw responseMessage.getParseException().getSourceException(); // viene gestito a modo dopo nel catch
  1304.                 
  1305.                 // transfer length
  1306.                 ServicesUtils.setTransferLength(openSPCoopProperties.getTransferLengthModes_ricezioneBuste(), 
  1307.                         req, res, responseMessage);
  1308.                 
  1309.                 //NOTA: Faccio la save per refreshare il ContentType. Necessario nel caso di attachment 
  1310.                 // (implementazione SAAJ della SUN)
  1311.                 responseMessage.updateContentType();
  1312.                 
  1313.                 // content type
  1314.                 ServicesUtils.setContentType(responseMessage, res);

  1316.                 // http status
  1317.                 boolean consume = true;
  1318.                 if(ServiceBinding.SOAP.equals(responseMessage.getServiceBinding()) ){
  1319.                     //SOAPBody body = responseMessage.castAsSoap().getSOAPBody();
  1320.                     OpenSPCoop2SoapMessage soapMessage = responseMessage.castAsSoap();
  1321.                     if(soapMessage.hasSOAPFault()){
  1322.                         consume = false; // può essere usato nel post out response handler
  1323.                         statoServletResponse = 500;
  1324.                         descrizioneSoapFault = " ("+SoapUtils.safe_toString(responseMessage.getFactory(), soapMessage.getSOAPBody().getFault(), false, logCore)+")";
  1325.                     }
  1326.                     else if(statoServletResponse==500) {
  1327.                         // in SOAP 500 deve essere associato con un fault
  1328.                         if(!soapMessage.isSOAPBodyEmpty()) {
  1329.                             statoServletResponse = 200;
  1330.                         }
  1331.                         else {
  1332.                             statoServletResponse = protocolFactory.createProtocolManager().getHttpReturnCodeEmptyResponseOneWay();
  1333.                         }
  1334.                     }
  1335.                 }
  1336.                 else if(responseMessage.castAsRest().isProblemDetailsForHttpApis_RFC7807() || 
  1337.                         (MessageRole.FAULT.equals(responseMessage.getMessageRole()) &&
  1338.                             (
  1339.                             MessageType.XML.equals(responseMessage.getMessageType()) 
  1340.                                     || 
  1341.                             MessageType.JSON.equals(responseMessage.getMessageType())
  1342.                             )
  1343.                         )
  1344.                     ) {
  1345.                     consume = false; // può essere usato nel post out response handler
  1346.                     String contentAsString = null;
  1347.                     try {
  1348.                         contentAsString = responseMessage.castAsRest().getContentAsString();
  1349.                     }catch(Throwable t) {
  1350.                         logCore.error("Parsing errore non riuscito: "+t.getMessage(),t);
  1351.                     }
  1352.                     if(contentAsString!=null && StringUtils.isNotEmpty(contentAsString)) {
  1353.                         descrizioneSoapFault = " ("+contentAsString+")";
  1354.                     }
  1355.                 }
  1356.                 res.setStatus(statoServletResponse);
  1357.                 
  1358.                 // esito calcolato prima del sendResponse, per non consumare il messaggio
  1359.                 esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(), 
  1360.                         statoServletResponse, requestInfo.getProtocolServiceBinding(),
  1361.                         responseMessage, proprietaErroreAppl,informazioniErrori,
  1362.                         pddContext);
  1363.                 
  1364.                 // se il tracciamento lo prevedo emetto un log
  1365.                 registraTracciaOutResponse = true;
  1366.                 transazioneDaAggiornare = registraTracciaOutResponse(context, postOutResponseContext,
  1367.                         dataAccettazioneRichiesta, dataIngressoRichiesta,
  1368.                         dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1369.                         esito, statoServletResponse,
  1370.                         idModulo, req, requestMessage, 
  1371.                         responseMessage, erroreConsegnaRisposta, responseMessageError,
  1372.                         msgDiag);
  1373.                 
  1374.                 // Il contentLenght, nel caso di TransferLengthModes.CONTENT_LENGTH e' gia' stato calcolato
  1375.                 // con una writeTo senza consume. Riuso il solito metodo per evitare differenze di serializzazione
  1376.                 // e cambiare quindi il content length effettivo.
  1377.                 sendInvoked = true;
  1378.                 if(TransferLengthModes.CONTENT_LENGTH.equals(openSPCoopProperties.getTransferLengthModes_ricezioneBuste())){
  1379.                     res.sendResponse(responseMessage, false);
  1380.                 } else {
  1381.                     res.sendResponse(responseMessage, consume);
  1382.                 }
  1383.                 
  1384.             }
  1385.             else if(responseMessage!=null && responseMessage.getForcedResponse()!=null) {
  1386.                 byte[]response = responseMessage.getForcedResponse().getContent();
  1387. //              if(response==null) {
  1388. //                  throw new Exception("Trovata configurazione 'forcedResponse' senza una vera risposta");
  1389. //              }
  1390.             
  1391.                 if(response!=null && response.length<1024) {
  1392.                     // Se il messaggio non è troppo grande lo aggiungo al diagnostico
  1393.                     try {
  1394.                         descrizioneSoapFault = "("+new String(response)+")";
  1395.                     }catch(Throwable t) {
  1396.                         descrizioneSoapFault = "";
  1397.                     }
  1398.                 }
  1399.                 
  1400.                 if(responseMessage.getForcedResponse().getHeadersValues()!=null &&
  1401.                         responseMessage.getForcedResponse().getHeadersValues().size()>0) {
  1402.                     Iterator<String> keys = responseMessage.getForcedResponse().getHeadersValues().keySet().iterator();
  1403.                     while (keys.hasNext()) {
  1404.                         String key = (String) keys.next();
  1405.                         List<String> values = responseMessage.getForcedResponse().getHeadersValues().get(key);
  1406.                         if(values!=null && !values.isEmpty()) {
  1407.                             for (int i = 0; i < values.size(); i++) {
  1408.                                 String value = values.get(i);
  1409.                                 String verbo = "";
  1410.                                 try{
  1411.                                     if(i==0) {
  1412.                                         verbo = "set";
  1413.                                         res.setHeader(key,value);
  1414.                                     }
  1415.                                     else {
  1416.                                         verbo = "add";
  1417.                                         res.addHeader(key,value);
  1418.                                     }
  1419.                                 }catch(Exception e){
  1420.                                     logCore.error("Response(Forced)."+verbo+"Header("+key+","+value+") error: "+e.getMessage(),e);
  1421.                                 }   
  1422.                             }
  1423.                         }
  1424.                     }   
  1425.                 }
  1426.                 
  1427.                 if(responseMessage.getForcedResponse().getContentType()!=null) {
  1428.                     res.setContentType(responseMessage.getForcedResponse().getContentType());
  1429.                 }
  1430.                 
  1431.                 if(responseMessage.getForcedResponse().getResponseCode()!=null) {
  1432.                     try{
  1433.                         statoServletResponse = Integer.parseInt(responseMessage.getForcedResponse().getResponseCode());
  1434.                     }catch(Exception e){
  1435.                         // ignore
  1436.                     }
  1437.                 }
  1438.                 else if(responseMessage!=null && responseMessage.getForcedResponseCode()!=null) {
  1439.                     try{
  1440.                         statoServletResponse = Integer.parseInt(responseMessage.getForcedResponseCode());
  1441.                     }catch(Exception e){
  1442.                         // ignore
  1443.                     }
  1444.                 }
  1445.                 res.setStatus(statoServletResponse);
  1446.                 
  1447.                 // esito calcolato prima del sendResponse, per non consumare il messaggio
  1448.                 esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(), 
  1449.                         statoServletResponse, requestInfo.getProtocolServiceBinding(),
  1450.                         responseMessage, proprietaErroreAppl,informazioniErrori,
  1451.                         pddContext);
  1452.                 
  1453.                 // se il tracciamento lo prevedo emetto un log
  1454.                 registraTracciaOutResponse = true;
  1455.                 transazioneDaAggiornare = registraTracciaOutResponse(context, postOutResponseContext,
  1456.                         dataAccettazioneRichiesta, dataIngressoRichiesta,
  1457.                         dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1458.                         esito, statoServletResponse,
  1459.                         idModulo, req, requestMessage, 
  1460.                         responseMessage, erroreConsegnaRisposta, responseMessageError,
  1461.                         msgDiag);
  1462.                 
  1463.                 if(response!=null) {
  1464.                     sendInvoked = true;
  1465.                     res.sendResponse(DumpByteArrayOutputStream.newInstance(response));
  1466.                 }
  1467.                 
  1468.             }
  1469.             else{
  1470.                 if(responseMessage!=null && responseMessage.getForcedResponseCode()!=null) {
  1471.                     try{
  1472.                         statoServletResponse = Integer.parseInt(responseMessage.getForcedResponseCode());
  1473.                     }catch(Exception e){
  1474.                         // ignore
  1475.                     }
  1476.                 }
  1477.                 else {
  1478.                     statoServletResponse = protocolFactory.createProtocolManager().getHttpReturnCodeEmptyResponseOneWay();
  1479.                 }
  1480.                 res.setStatus(statoServletResponse);
  1481.                 httpEmptyResponse = true;
  1482.                 // carico-vuoto
  1483.                 esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(), 
  1484.                         statoServletResponse, requestInfo.getProtocolServiceBinding(),
  1485.                         responseMessage, proprietaErroreAppl,informazioniErrori,
  1486.                         pddContext);
  1487.                 
  1488.                 // se il tracciamento lo prevedo emetto un log
  1489.                 registraTracciaOutResponse = true;
  1490.                 transazioneDaAggiornare = registraTracciaOutResponse(context, postOutResponseContext,
  1491.                         dataAccettazioneRichiesta, dataIngressoRichiesta,
  1492.                         dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1493.                         esito, statoServletResponse,
  1494.                         idModulo, req, requestMessage, 
  1495.                         responseMessage, erroreConsegnaRisposta, responseMessageError,
  1496.                         msgDiag);
  1497.             }
  1498.             
  1499.         }catch(Throwable e){
  1500.             // Errore nell'invio della risposta
  1501.             logCore.error("ErroreGenerale",e);
  1502.             erroreConsegnaRisposta = e;
  1503.             
  1504.             erroreConnessioneClient = ServicesUtils.isConnessioneClientNonDisponibile(e);
  1505.             if(!erroreConnessioneClient && ServicesUtils.isConnessioneServerReadTimeout(e)) {
  1506.                 erroreResponseTimeout = true; // non e' stato possibile consegnare tutta la risposta. Il client ha ricevuto 200 ma non ha ricevuto la risposta per intero
  1507.                 erroreConsegnaRisposta = new CoreException("Connessione con il backend dell'API non più disponibile: "+e.getMessage(),e);
  1508.             }
  1509.             if(!erroreConnessioneClient && !erroreResponseTimeout && ServicesUtils.isResponsePayloadTooLarge(e)) {
  1510.                 erroreResponsePayloadTooLarge = true;  // non e' stato possibile consegnare tutta la risposta. Il client ha ricevuto 200 ma non ha ricevuto la risposta per intero
  1511.                 erroreConsegnaRisposta = new CoreException("Risposta ricevuta dal backend dell'API non gestibile: "+e.getMessage(),e);
  1512.             }
  1513.             
  1514.             // Genero risposta con errore
  1515.             try{
  1516.                 if(sendInvoked==false) {
  1517.                     // nel caso sia già stato inoltrata una risposta non e' più possibile modificarlo cosi come tutti gli header etc... 
  1518.                 
  1519.                     InformazioniErroriInfrastrutturali informazioniErrori_error = new InformazioniErroriInfrastrutturali();
  1520.                     if( (responseMessage!=null && responseMessage.getParseException() != null) ||
  1521.                             (pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION))){
  1522.                         informazioniErrori_error.setContenutoRispostaNonRiconosciuto(true);
  1523.                         ParseException parseException = null;
  1524.                         if( responseMessage!=null && responseMessage.getParseException() != null ){
  1525.                             parseException = responseMessage.getParseException();
  1526.                         }
  1527.                         else{
  1528.                             parseException = (ParseException) pddContext.getObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  1529.                         }
  1530.                         String msgErrore = parseException.getParseException().getMessage();
  1531.                         if(msgErrore==null){
  1532.                             msgErrore = parseException.getParseException().toString();
  1533.                         }
  1534.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  1535.                         logCore.error("parsingExceptionRisposta",parseException.getSourceException());
  1536.                         msgDiag.logPersonalizzato("parsingExceptionRisposta");
  1537.                         responseMessageError = this.generatoreErrore.buildErroreProcessamento(pddContext, IntegrationFunctionError.UNPROCESSABLE_RESPONSE_CONTENT,
  1538.                                 ErroriIntegrazione.ERRORE_440_PARSING_EXCEPTION_RISPOSTA.
  1539.                                 getErrore440_MessaggioRispostaMalformato(parseException.getParseException()));
  1540.                     } 
  1541.                     else {
  1542.                         IntegrationFunctionError ife = IntegrationFunctionError.INTERNAL_RESPONSE_ERROR;
  1543.                         if(e instanceof HandlerException) {
  1544.                             HandlerException he = (HandlerException) e;
  1545.                             if(he.getIntegrationFunctionError()!=null) {
  1546.                                 ife = he.getIntegrationFunctionError();
  1547.                             }
  1548.                         }
  1549.                         responseMessageError = this.generatoreErrore.buildErroreProcessamento(pddContext, ife,
  1550.                                 ErroriIntegrazione.ERRORE_426_SERVLET_ERROR.getErrore426_ServletError(false, e));
  1551.                     }
  1552.                     // transfer length
  1553.                     ServicesUtils.setTransferLength(openSPCoopProperties.getTransferLengthModes_ricezioneBuste(), 
  1554.                             req, res, responseMessageError);
  1555.                                     
  1556.                     // content type
  1557.                     ServicesUtils.setContentType(responseMessageError, res);
  1558.                     
  1559.                     // http status
  1560.                     if(responseMessageError!=null && responseMessageError.getForcedResponseCode()!=null) {
  1561.                         try{
  1562.                             statoServletResponse = Integer.parseInt(responseMessageError.getForcedResponseCode());
  1563.                             res.setStatus(statoServletResponse);
  1564.                         }catch(Exception eStatus){
  1565.                             // ignore
  1566.                         }
  1567.                     }
  1568.                     if(responseMessageError!=null && ServiceBinding.SOAP.equals(responseMessageError.getServiceBinding()) ){
  1569.                         SOAPBody body = responseMessageError.castAsSoap().getSOAPBody();
  1570.                         if(body!=null && body.hasFault()){
  1571.                             statoServletResponse = 500;
  1572.                             res.setStatus(statoServletResponse);
  1573.                             descrizioneSoapFault = " ("+SoapUtils.safe_toString(responseMessageError.getFactory(), body.getFault(), false, logCore)+")";
  1574.                         }
  1575.                     }
  1576.                     
  1577.                     // esito calcolato prima del sendResponse, per non consumare il messaggio
  1578.                     esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(), 
  1579.                             statoServletResponse, requestInfo.getProtocolServiceBinding(),
  1580.                             responseMessageError, proprietaErroreAppl, informazioniErrori_error,
  1581.                             pddContext);
  1582.                     
  1583.                     // se il tracciamento lo prevedo emetto un log
  1584.                     // se ho già provato prima a tracciare non lo faccio un'altra volta
  1585.                     if(!registraTracciaOutResponse) {
  1586.                         transazioneDaAggiornare = registraTracciaOutResponse(context, postOutResponseContext,
  1587.                             dataAccettazioneRichiesta, dataIngressoRichiesta,
  1588.                             dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1589.                             esito, statoServletResponse,
  1590.                             idModulo, req, requestMessage, 
  1591.                             responseMessage, erroreConsegnaRisposta, responseMessageError,
  1592.                             msgDiag);
  1593.                     }
  1594.                     
  1595.                     // Il contentLenght, nel caso di TransferLengthModes.CONTENT_LENGTH e' gia' stato calcolato
  1596.                     // con una writeTo senza consume. Riuso il solito metodo per evitare differenze di serializzazione
  1597.                     // e cambiare quindi il content length effettivo.
  1598.                     //if(TransferLengthModes.CONTENT_LENGTH.equals(openSPCoopProperties.getTransferLengthModes_ricezioneBuste())){
  1599.                     //  res.sendResponse(responseMessageError, false);
  1600.                     //} else {
  1601.                         //res.sendResponse(responseMessageError, true);
  1602.                         res.sendResponse(responseMessageError, false); // può essere usato nel post out response handler
  1603.                     //}
  1604.                 }
  1605.                             
  1606.             }catch(Throwable error){
  1607.                 
  1608.                 if(!erroreConnessioneClient){
  1609.                     erroreConnessioneClient = ServicesUtils.isConnessioneClientNonDisponibile(error);
  1610.                 }
  1611.                 
  1612.                 logCore.error("Generazione di un risposta errore non riuscita",error);
  1613.                 statoServletResponse = 500;
  1614.                 try{
  1615.                     IntegrationFunctionError ife = null;
  1616.                     if(error instanceof HandlerException) {
  1617.                         HandlerException he = (HandlerException) error;
  1618.                         if(he.getIntegrationFunctionError()!=null) {
  1619.                             ife = he.getIntegrationFunctionError();
  1620.                         }
  1621.                     }
  1622.                     if(ife!=null) {
  1623.                         responseMessageError = this.generatoreErrore.buildFault(error, pddContext, ife);
  1624.                     }
  1625.                     else {
  1626.                         responseMessageError = this.generatoreErrore.buildFault(error, pddContext);
  1627.                     }
  1628.                     if(responseMessageError!=null && responseMessageError.getForcedResponseCode()!=null) {
  1629.                         try{
  1630.                             statoServletResponse = Integer.parseInt(responseMessageError.getForcedResponseCode());
  1631.                         }catch(Exception eStatus){
  1632.                             // ignore
  1633.                         }
  1634.                     }
  1635.                     
  1636.                     try{
  1637.                         res.setStatus(statoServletResponse);
  1638.                     }catch(Exception eStatus){
  1639.                         logCore.error("Response.setStatus("+statoServletResponse+") error: "+eStatus.getMessage(),eStatus);
  1640.                     }
  1641.                     
  1642.                     res.sendResponse(responseMessageError, false); // può essere usato nel post out response handler
  1643.                 }catch(Throwable  eError){
  1644.                     if(!erroreConnessioneClient){
  1645.                         erroreConnessioneClient = ServicesUtils.isConnessioneClientNonDisponibile(eError);
  1646.                     }
  1647.                     try {
  1648.                         res.setStatus(statoServletResponse);
  1649.                     }catch(Throwable t) {
  1650.                         // ignore
  1651.                     }
  1652.                     try{
  1653.                         res.sendResponse(DumpByteArrayOutputStream.newInstance(error.toString().getBytes()));
  1654.                     }catch(Exception erroreStreamChiuso){ 
  1655.                         erroreConnessioneClient = true;
  1656.                         //se lo stream non e' piu' disponibile non si potra' consegnare alcuna risposta
  1657.                     }
  1658.                 }
  1659.                 try{
  1660.                     esito = protocolFactory.createEsitoBuilder().getEsito(req.getURLProtocolContext(),EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX);
  1661.                 }catch(Exception eBuildError){
  1662.                     esito = EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  1663.                 }
  1664.             }
  1665.             
  1666.         }
  1667.         finally{
  1668.             
  1669.             if(sendInvoked==false) {
  1670.                 // nel caso sia già stato inoltrata una risposta non e' più possibile modificarlo cosi come tutti gli header etc... 
  1671.                 statoServletResponse = res.getResponseStatus(); // puo' essere "trasformato" da api engine
  1672.             }
  1673.             msgDiag.addKeyword(CostantiPdD.KEY_CODICE_CONSEGNA, ""+statoServletResponse);
  1674.             msgDiag.addKeyword(CostantiPdD.KEY_SOAP_FAULT, descrizioneSoapFault);
  1675.             
  1676.             try{

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

  1805.         
  1806.         
  1807.         
  1808.         
  1809.         
  1810.         
  1811.         
  1812.         /* ------------  PostOutResponseHandler ------------- */
  1813.         
  1814.         if(postOutResponseContext!=null){
  1815.             try{
  1816.                 updateContext(context, postOutResponseContext,
  1817.                         dataAccettazioneRichiesta, dataIngressoRichiesta,
  1818.                         dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1819.                         esito, statoServletResponse,
  1820.                         idModulo, req, requestMessage, 
  1821.                         responseMessage, erroreConsegnaRisposta, responseMessageError);
  1822.                 postOutResponseContext.setTransazioneDaAggiornare(transazioneDaAggiornare);
  1823.                 
  1824.             }catch(Exception e){
  1825.                 msgDiag.logErroreGenerico(e,"postOutResponse, preparazione contesto");
  1826.             }
  1827.             
  1828.             GestoreHandlers.postOutResponse(postOutResponseContext, msgDiag, logCore);
  1829.         }
  1830.         
  1831.         
  1832.         
  1833.         
  1834.         
  1835.         
  1836.         
  1837.         
  1838.         
  1839.         
  1840.         // *** Rilascio risorse NotifierInputStream ***
  1841.         
  1842.         // request
  1843.         try{
  1844.             if(requestMessage!=null && requestMessage.getNotifierInputStream()!=null){
  1845.                 requestMessage.getNotifierInputStream().close();
  1846.             }
  1847.         }catch(Exception e){
  1848.             msgDiag.logErroreGenerico(e,"Rilascio risorse NotifierInputStream richiesta");
  1849.         }
  1850.         
  1851.         // response
  1852.         try{
  1853.             if(responseMessage!=null && responseMessage.getNotifierInputStream()!=null){
  1854.                 responseMessage.getNotifierInputStream().close();
  1855.             }
  1856.         }catch(Exception e){
  1857.             msgDiag.logErroreGenerico(e,"Rilascio risorse NotifierInputStream risposta");
  1858.         }
  1859.         
  1860.         
  1861.         
  1862.         
  1863.         
  1864.         
  1865.         
  1866.         
  1867.         
  1868.         
  1869.         // *** GB ***
  1870.         requestMessage = null;
  1871.         responseMessage = null;
  1872.         responseMessageError = null;
  1873.         // *** GB ***
  1874.         
  1875.         return;
  1876.     }


  1879.     private void updateContext(RicezioneBusteContext context, PostOutResponseContext postOutResponseContext,
  1880.             Date dataAccettazioneRichiesta, Date dataIngressoRichiesta,
  1881.             Date dataPrimaSpedizioneRisposta, Date dataRispostaSpedita,
  1882.             EsitoTransazione esito, int statoServletResponse,
  1883.             String idModulo, ConnectorInMessage req, OpenSPCoop2Message requestMessage, 
  1884.             OpenSPCoop2Message responseMessage, Throwable erroreConsegnaRisposta, OpenSPCoop2Message responseMessageError) throws ConnectorException {
  1885.         if(postOutResponseContext!=null){
  1886.             postOutResponseContext.getPddContext().addObject(CostantiPdD.DATA_ACCETTAZIONE_RICHIESTA, dataAccettazioneRichiesta);
  1887.             if(dataIngressoRichiesta!=null){
  1888.                 postOutResponseContext.getPddContext().addObject(CostantiPdD.DATA_INGRESSO_RICHIESTA, dataIngressoRichiesta);
  1889.             }
  1890.             postOutResponseContext.setDataElaborazioneMessaggio(DateManager.getDate());
  1891.             postOutResponseContext.setDataPrimaSpedizioneRisposta(dataPrimaSpedizioneRisposta);
  1892.             postOutResponseContext.setDataRispostaSpedita(dataRispostaSpedita);
  1893.             postOutResponseContext.setEsito(esito);
  1894.             postOutResponseContext.setReturnCode(statoServletResponse);
  1895.             postOutResponseContext.setResponseHeaders(context.getResponseHeaders());
  1896.             postOutResponseContext.setProtocollo(context.getProtocol());
  1897.             postOutResponseContext.setIntegrazione(context.getIntegrazione());
  1898.             if(context.getTipoPorta()!=null)
  1899.                 postOutResponseContext.setTipoPorta(context.getTipoPorta());    
  1900.             postOutResponseContext.setIdModulo(idModulo);
  1901.             
  1902.             if(requestMessage!=null){
  1903.                 long incomingRequestMessageContentLength = requestMessage.getIncomingMessageContentLength();
  1904.                 long outgoingRequestMessageContentLenght = requestMessage.getOutgoingMessageContentLength();
  1905.                 if(incomingRequestMessageContentLength<0){
  1906.                     int cl = req.getContentLength();
  1907.                     if(cl>0){
  1908.                         /**System.out.println("HTTP");*/
  1909.                         incomingRequestMessageContentLength = cl + 0l;
  1910.                     }
  1911.                     else{
  1912.                         /**System.out.println("FLUSH");*/
  1913.                         // forzo la lettura del messaggio per impostare la dimensione della richiesta
  1914.                         try{
  1915.                             requestMessage.writeTo(NullOutputStream.INSTANCE, true);
  1916.                         }catch(Exception eFlush){
  1917.                             // ignore
  1918.                         }
  1919.                         incomingRequestMessageContentLength = requestMessage.getIncomingMessageContentLength();
  1920.                     }
  1921.                 }
  1922.                 postOutResponseContext.setInputRequestMessageSize(incomingRequestMessageContentLength);
  1923.                 postOutResponseContext.setOutputRequestMessageSize(outgoingRequestMessageContentLenght);
  1924.             }else{
  1925.                 postOutResponseContext.setInputRequestMessageSize(req.getContentLength()+0l);
  1926.             }
  1927.             
  1928.             if(erroreConsegnaRisposta!=null){
  1929.                 if(responseMessageError!=null){
  1930.                     postOutResponseContext.setInputResponseMessageSize(responseMessageError.getIncomingMessageContentLength());
  1931.                     postOutResponseContext.setOutputResponseMessageSize(responseMessageError.getOutgoingMessageContentLength());
  1932.                     postOutResponseContext.setMessaggio(responseMessageError);
  1933.                 }else{
  1934.                     if(responseMessage!=null && !responseMessage.isForcedEmptyResponse() && responseMessage.getForcedResponse()==null){
  1935.                         postOutResponseContext.setInputResponseMessageSize(responseMessage.getIncomingMessageContentLength());
  1936.                         postOutResponseContext.setOutputResponseMessageSize(responseMessage.getOutgoingMessageContentLength());
  1937.                         postOutResponseContext.setMessaggio(responseMessage);
  1938.                     }
  1939.                 }
  1940.                 postOutResponseContext.setErroreConsegna(erroreConsegnaRisposta.toString()); // NOTA: lasciare e.toString()
  1941.             }
  1942.             else if(responseMessage!=null && !responseMessage.isForcedEmptyResponse() && responseMessage.getForcedResponse()==null){
  1943.                 postOutResponseContext.setInputResponseMessageSize(responseMessage.getIncomingMessageContentLength());
  1944.                 postOutResponseContext.setOutputResponseMessageSize(responseMessage.getOutgoingMessageContentLength());
  1945.                 postOutResponseContext.setMessaggio(responseMessage);
  1946.             }
  1947.             else if(responseMessage!=null && responseMessage.getForcedResponse()!=null &&
  1948.                     responseMessage.getForcedResponse().getContent()!=null) {
  1949.                 postOutResponseContext.setInputResponseMessageSize(responseMessage.getIncomingMessageContentLength());
  1950.                 postOutResponseContext.setOutputResponseMessageSize((long) responseMessage.getForcedResponse().getContent().length);
  1951.             }
  1952.         }
  1953.     }
  1954.     
  1955.     
  1956.     private Transazione registraTracciaOutResponse(RicezioneBusteContext context, PostOutResponseContext postOutResponseContext,
  1957.             Date dataAccettazioneRichiesta, Date dataIngressoRichiesta,
  1958.             Date dataPrimaSpedizioneRisposta, Date dataRispostaSpedita,
  1959.             EsitoTransazione esito, int statoServletResponse,
  1960.             String idModulo, ConnectorInMessage req, OpenSPCoop2Message requestMessage, 
  1961.             OpenSPCoop2Message responseMessage, Throwable erroreConsegnaRisposta, OpenSPCoop2Message responseMessageError, 
  1962.             MsgDiagnostico msgDiag) throws HandlerException {

  1964.         try {
  1965.         
  1966.             if(postOutResponseContext!=null) {
  1967.                 updateContext(context, postOutResponseContext,
  1968.                         dataAccettazioneRichiesta, dataIngressoRichiesta,
  1969.                         dataPrimaSpedizioneRisposta, dataRispostaSpedita,
  1970.                         esito, statoServletResponse,
  1971.                         idModulo, req, requestMessage, 
  1972.                         responseMessage, erroreConsegnaRisposta, responseMessageError);
  1973.                 
  1974.                 TracciamentoManager tracciamentoManager = new TracciamentoManager(FaseTracciamento.OUT_RESPONSE);
  1975.                 if(!tracciamentoManager.isTransazioniEnabled()) {
  1976.                     return null;
  1977.                 }
  1978.                 
  1979.                 InformazioniTransazione info = new InformazioniTransazione(postOutResponseContext);
  1980.                 
  1981.                 tracciamentoManager.invoke(info, postOutResponseContext.getEsito(), context.getResponseHeaders(), msgDiag);
  1982.                 
  1983.                 return info.getTransazioneDaAggiornare();
  1984.             }
  1985.             
  1986.         }catch(Exception e) {
  1987.             ServicesUtils.processTrackingException(e, postOutResponseContext.getLogCore(), FaseTracciamento.OUT_RESPONSE, context.getPddContext());
  1988.         }
  1989.         
  1990.         return null;
  1991.     }
  1992.     
  1993.     private void registraTracciaInRequest(RicezioneBusteContext context,
  1994.             IProtocolFactory<?> protocolFactory, Logger log,
  1995.             MsgDiagnostico msgDiag) throws HandlerException {

  1997.         try {
  1998.         
  1999.             TracciamentoManager tracciamentoManager = new TracciamentoManager(FaseTracciamento.IN_REQUEST);
  2000.             if(!tracciamentoManager.isTransazioniEnabled()) {
  2001.                 return;
  2002.             }
  2003.                 
  2004.             InformazioniTransazione info = new InformazioniTransazione();
  2005.             info.setContext(context.getPddContext());
  2006.             info.setTipoPorta(context.getTipoPorta());
  2007.             info.setProtocolFactory(protocolFactory);
  2008.             info.setProtocollo(context.getProtocol());
  2009.             info.setIntegrazione(context.getIntegrazione());
  2010.             info.setIdModulo(context.getIdModulo());
  2011.             
  2012.             TransportRequestContext transportRequestContext = null;
  2013.             if(context.getMessageRequest()!=null) {
  2014.                 transportRequestContext = context.getMessageRequest().getTransportRequestContext();
  2015.             }
  2016.             String esitoContext = EsitoBuilder.getTipoContext(transportRequestContext, EsitiProperties.getInstance(log, protocolFactory), log);
  2017.             
  2018.             tracciamentoManager.invoke(info, esitoContext, msgDiag);
  2019.             
  2020.         }catch(Exception e) {
  2021.             ServicesUtils.processTrackingException(e, log, FaseTracciamento.IN_REQUEST, context.getPddContext());
  2022.         }
  2023.         
  2024.     }
  2025. }


Created with JaCoCo 0.8.8.202204050719